p2gpamesw
/
LiteOS-Reading
2
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

111

Browse Source
pull/10/head
p2gpamesw 11 months ago
parent 51d4c9f4f9 06b38cbc74
commit 3fd610943a
38 changed files with 1978 additions and 585 deletions
Show Stats Download Patch File Download Diff File

0
fuaojia_branch.txt
Unescape View File

0
hjc/hjc.txt
Unescape View File

172
src/kernel/base/mem/bestfit_little/los_heap.c
Unescape View File

@ -43,9 +43,9 @@ extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#define HEAP_CAST(t, exp) ((t)(exp))
#define HEAP_ALIGN sizeof(UINTPTR)
#define MALLOC_MAXSIZE (0xFFFFFFFF - HEAP_ALIGN + 1)
#define HEAP_CAST(t, exp) ((t)(exp))//这个宏定义是一个类型转换的快捷方式。它接受两个参数，t 表示目标类型，exp 是需要进行类型转换的表达式。这个宏最终会将 exp 转换为类型 t。
#define HEAP_ALIGN sizeof(UINTPTR)//这个宏定义定义了 HEAP_ALIGN，它的值是 sizeof(UINTPTR)。sizeof 操作符用于返回其操作数的大小（以字节为单位），所以 HEAP_ALIGN 的值将取决于 UINTPTR 类型的大小。
#define MALLOC_MAXSIZE (0xFFFFFFFF - HEAP_ALIGN + 1)//这个宏定义了 MALLOC_MAXSIZE，它的值是 0xFFFFFFFF - HEAP_ALIGN + 1。在这里，0xFFFFFFFF 表示一个32位无符号整数的最大值，HEAP_ALIGN 已经在上面定义过了。这个宏定义似乎是用来表示在分配内存时可能的最大尺寸。
/*
* Description : look up the next memory node according to one memory node in the memory block list.
@ -53,13 +53,25 @@ extern "C" {
* struct LosHeapNode *node --- Size of memory in bytes to allocate
* Return : Pointer to next memory node
*/
/*这个函数的作用是获取下一个堆节点的指针。具体实现过程如下：
如果当前节点已经是最后一个节点（即 node 等于堆管理器的尾节点），则返回 NULL。
否则，计算出下一个节点的指针。根据结构体 LosHeapNode 的定义可知，每个节点都有一个 data 指针和一个 size 字段。为了得到下一个节点的指针，需要将当前节点的 data 指针加上当前节点的 size 字段。
这个结果是一个地址，需要将其转换成 struct LosHeapNode* 类型的指针。可以通过先将地址转换为 UINTPTR 类型，再强制转换为 struct LosHeapNode* 来实现这一点。
返回下一个节点的指针。*/
struct LosHeapNode* OsHeapPrvGetNext(struct LosHeapManager *heapMan, struct LosHeapNode *node)
{
return (heapMan->tail == node) ? NULL : (struct LosHeapNode *)(UINTPTR)(node->data + node->size);
}
#ifdef LOSCFG_MEM_TASK_STAT
/*该函数接受两个参数：heapMan 表示堆管理器的指针，size 表示堆的初始大小。该函数的作用是初始化堆的统计信息，
即将 heapMan->stat 结构体清零，
并设置 heapMan->stat.memTotalUsed 和 heapMan->stat.memTotalPeak，表示内存使用情况的总量和峰值。
具体实现过程如下：
首先调用 memset_s 函数将 heapMan->stat 清零，确保所有字段的值都为 0。
接着，设置 heapMan->stat.memTotalUsed 的值为 sizeof(struct LosHeapNode) + sizeof(struct LosHeapManager)，即堆管理器结构体和堆节点结构体的大小之和，这是堆使用的总
将 heapMan->stat.memTotalPeak 的初始值也设为 heapMan->stat.memTotalUsed，表示在堆使用过程中的最高峰值。
这段代码的前提条件是 LOSCFG_MEM_TASK_STAT 宏定义已经被定义，否则该函数不会被编译。*/
VOID OsHeapStatInit(struct LosHeapManager *heapMan, UINT32 size)
{
(VOID)memset_s(&heapMan->stat, sizeof(Memstat), 0, sizeof(Memstat));
@ -67,7 +79,16 @@ VOID OsHeapStatInit(struct LosHeapManager *heapMan, UINT32 size)
heapMan->stat.memTotalUsed = sizeof(struct LosHeapNode) + sizeof(struct LosHeapManager);
heapMan->stat.memTotalPeak = heapMan->stat.memTotalUsed;
}
/*该函数的作用是向堆的统计信息中添加被使用的内存块。具体实现过程如下：
首先定义了两个变量 taskId 和 blockSize。taskId 用于记录当前任务的 ID，blockSize 表示要添加的内存块的大小，
包括堆节点结构体和节点存储的数据大小。
然后，通过条件判断来确定 taskId 的值。如果当前任务不为空且处于非中断状态（OS_INT_INACTIVE），
则将 taskId 设置为当前任务的 ID（通过 LOS_CurTaskIDGet 函数获取）。否则，将 taskId 设置为 TASK_NUM - 1，
表示该内存块属于最后一个任务。
将节点的 taskId 字段设置为 taskId，以便记录该内存块所属的任务。
最后，调用 OS_MEM_ADD_USED 宏来更新堆的统计信息。该宏会将 blockSize 和 taskId 传递给堆管理器的 stat 结构体，
以便记录已使用内存的总量和各任务的内存使用情况。
该函数的目的是在堆的统计信息中记录每个内存块的使用情况，以便进行内存管理和监控。*/
VOID OsHeapStatAddUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
{
UINT32 taskId;
@ -87,7 +108,13 @@ VOID OsHeapStatAddUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
node->taskId = taskId;
OS_MEM_ADD_USED(&heapMan->stat, blockSize, taskId);
}
/*该函数的作用是从堆的统计信息中减少被使用的内存块。具体实现过程如下：
首先定义了两个变量 taskId 和 blockSize。taskId 用于记录当前节点所属的任务 ID，该值在添加内存块时被设置；
blockSize 表示要减少的内存块的大小，包括堆节点结构体和节点存储的数据大小。
调用 OS_MEM_REDUCE_USED 宏来更新堆的统计信息。该宏会将 blockSize 和 taskId 传递给堆管理器的 stat 结构体，
以便记录已使用内存的总量和各任务的内存使用情况。
该函数的目的是在堆的统计信息中记录每个内存块的使用情况，以便进行内存管理和监控。和 OsHeapStatAddUsed 函数相反，
该函数的作用是将内存块从使用中状态转变为未使用状态。*/
VOID OsHeapStatDecUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
{
UINT32 taskId = node->taskId;
@ -97,17 +124,25 @@ VOID OsHeapStatDecUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
}
#else /* LOSCFG_MEM_TASK_STAT */
//函数用于初始化堆管理器的内存统计信息。它接受两个参数：heapMan 表示堆管理器的指针，size 表示堆的总大小。在这个备选实现中，该函数没有任何具体的实现操作，直接返回。
VOID OsHeapStatInit(struct LosHeapManager *heapMan, UINT32 size) { }
//函数用于向堆的统计信息中添加被使用的内存块。它接受两个参数：heapMan 表示堆管理器的指针，node 表示要添加到统计信息中的堆节点指针。在这个备选实现中，该函数没有任何具体的实现操作，什么也不做。
VOID OsHeapStatAddUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node) { }
//函数用于从堆的统计信息中减少被使用的内存块。它接受两个参数：heapMan 表示堆管理器的指针，node 表示要从统计信息中减少使用的堆节点指针。在这个备选实现中，该函数没有任何具体的实现操作，什么也不做。
VOID OsHeapStatDecUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node) { }
#endif /* LOSCFG_MEM_TASK_STAT */
#ifdef LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK
/*这段代码实现了一个堆完整性检查的函数 OsHeapIntegrityCheck，用于检查堆内存的完整性，
以确保堆管理器中的内存块没有被破坏或越界。让我逐步解释这段代码的功能：
首先，通过 (struct LosHeapNode *)(heap + 1) 的方式来获取第一个堆节点的地址，其中 heap 是指向堆管理器结构体的指针。
然后，计算出堆的起始地址和结束地址，其中 heapStart 表示堆的起始地址，heapEnd 表示堆的结束地址。
接下来进入循环，遍历堆中的每个节点。在循环内部，首先检查当前节点的地址是否位于堆的范围内，如果节点地址小于堆的起始地址或大于堆的结束地址，
则说明堆节点已经被破坏或越界，此时触发错误处理并返回 LOS_NOK 表示检查失败。
如果当前节点的地址在合法范围内，则通过 OsHeapPrvGetNext 函数获取下一个节点的地址，继续进行下一轮的检查。
当所有节点都通过合法性检查后，函数返回 LOS_OK 表示堆的完整性检查通过。
总之，这段代码实现了对堆内存完整性的检查，避免了堆内存被破坏或越界，确保了堆管理器中的内存块的正确性。*/
UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
{
struct LosHeapNode *node = (struct LosHeapNode *)(heap + 1);
@ -127,7 +162,7 @@ UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
}
#else /* LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK */
//这段代码实现了一个名为 OsHeapIntegrityCheck 的函数，它接受一个指向 LosHeapManager 结构体的指针作为参数，并直接返回 LOS_OK。
UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
{
return LOS_OK;
@ -136,12 +171,16 @@ UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
#endif /* LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK */
#ifdef LOSCFG_KERNEL_MEM_SLAB_EXTENTION
/*接受一个指向内存池的指针 pool 和一个表示需要分配内存大小的参数 size。
在函数内部，调用 OsHeapAlloc 函数将内存分配操作委托给堆内存管理器进行处理。
最终将堆内存管理器返回的内存分配结果直接返回给调用者。*/
VOID *OsMemAlloc(VOID *pool, UINT32 size)
{
return OsHeapAlloc(pool, size);
}
/*接受一个指向内存池的指针 pool 和一个指向待释放内存块的指针 ptr。
在函数内部，调用 OsHeapFree 函数将内存释放操作委托给堆内存管理器进行处理。
检查堆内存管理器的释放操作是否成功，如果成功则返回 LOS_OK 表示释放成功，否则返回 LOS_NOK 表示释放失败。*/
UINT32 OsMemFree(VOID *pool, const VOID *ptr)
{
if (OsHeapFree(pool, ptr) == TRUE) {
@ -160,6 +199,19 @@ UINT32 OsMemFree(VOID *pool, const VOID *ptr)
* UITN32 size --- size of the heap memory pool
* Return : 1:success 0:error
*/
/*这段代码实现了一个名为 OsHeapInit 的函数，用于初始化堆内存管理器。让我逐步解释这段代码的功能：
首先，函数接受一个指向内存池的指针 pool 和表示内存池大小的参数 size。
接着，代码将 pool 指针强制类型转换为 struct LosHeapManager 类型的指针 heapMan，以便后续对堆管理器结构体成员的操作。
然后，代码执行了一系列的条件检查：
检查 heapMan 是否为 NULL，或者内存池的大小是否小于等于堆管理器结构体和堆节点结构体所需的空间大小之和。
如果满足其中任何一个条件，函数将返回 FALSE。
如果条件检查通过，接下来的操作包括：
使用 memset_s 函数将整个内存池的内容初始化为 0。
设置堆管理器结构体中的 size 成员为 size - sizeof(struct LosHeapManager)。
将 head 和 tail 指针指向内存池中的起始位置，并初始化堆节点的相关属性，如 used、prev 和 size。
调用 OsHeapStatInit 函数对堆内存管理器进行统计信息的初始化。
最后，函数返回 TRUE 表示堆内存管理器初始化成功。
总之，这段代码实现了对堆内存管理器的初始化操作，包括内存池的清零、设置管理器结构体的各个成员值，以及进行统计信息的初始化。这是堆内存分配器在启动阶段需要执行的关键操作，以确保后续的内存分配和释放能够正常进行。*/
BOOL OsHeapInit(VOID *pool, UINT32 size)
{
struct LosHeapNode *node = NULL;
@ -192,6 +244,33 @@ BOOL OsHeapInit(VOID *pool, UINT32 size)
* UINT32 size --- size of the heap memory pool
* Return : NULL:error, other value:the address of the memory we alloced
*/
/*这段代码实现了一个名为 OsHeapAlloc 的函数，用于在堆内存管理器中分配指定大小的内存块。让我逐步解释这段代码的功能：
首先，函数接受一个指向内存池的指针 pool 和表示要分配的内存块大小的参数 size。
接着，代码定义了一些局部变量，包括 node、next、best、ptr 和 alignSize，用于记录堆节点和其他临时数据。
heapMan 是将 pool 指针强制类型转换为 struct LosHeapManager 类型的指针，以便后续对堆管理器结构体成员的操作。
然后，代码执行了一系列的条件检查：
检查 heapMan 是否为 NULL，或者要分配的内存块大小是否超过了最大允许的大小 MALLOC_MAXSIZE。如果满足其中任何一个条件，函数将返回 NULL。
如果条件检查通过，接下来的操作包括：
调用 OsHeapIntegrityCheck 函数对堆内存管理器进行完整性检查。如果检查失败（返回值不等于 LOS_OK），函数将返回 NULL。
然后，代码从堆内存管理器的尾部开始遍历堆节点，寻找合适的空闲节点来分配内存块。具体过程如下：
判断当前节点是否未被使用（node->used == 0）且大小足够容纳请求的对齐后的大小（node->size >= alignSize）。
如果是，则更新 best 指针，选择找到的第一个合适的节点。
如果找到的节点大小正好与请求的对齐后的大小相等（best->size == alignSize），跳转到 SIZE_MATCH 标签处。
循环遍历完所有节点后，函数将根据找到的最佳节点进行不同的处理：
如果找到了合适的节点（best != NULL），则继续下面的操作。
如果找到的节点大小与对齐后的大小完全匹配（即跳转到 SIZE_MATCH 标签处），直接执行后续处理操作。
否则，函数将在找到的节点上分割出一个大小为 alignSize 的内存块，并更新相关节点和管理器的属性值。
最后，函数返回分配的内存块的起始地址 ptr。
总之，这段代码实现了在堆内存管理器中分配指定大小的内存块的功能。它会遍历堆节点，寻找满足条件的空闲节点，并根据需要进行内存分割，以满足对齐要求。如果分配失败或出现错误，函数将返回 NULL。*/
VOID *OsHeapAlloc(VOID *pool, UINT32 size)
{
struct LosHeapNode *node = NULL;
@ -222,11 +301,18 @@ VOID *OsHeapAlloc(VOID *pool, UINT32 size)
}
/* alloc failed */
/*这是一个条件判断语句，如果找到的最佳节点为空（即没有足够大小的空闲节点），则执行花括号中的代码块。*/
if (best == NULL) {
PRINT_ERR("there's not enough mem to alloc 0x%x Bytes!\n", alignSize);
goto OUT;
}
PRINT_ERR("there's not enough mem to alloc 0x%x Bytes!\n", alignSize);//在没有足够空闲内存来分配请求大小的内存块时，打印错误信息，提示用户无法分配指定大小的内存。
goto OUT;//跳转到标签 OUT 处，这通常是用于执行清理和释放资源的操作。
}
/*这是另一个条件判断语句，用于判断是否有足够的空间将找到的节点分割为两部分，以满足请求的大小，并且保留一个足够大的空洞来放置下一个节点的元数据。*/
/*node = (struct LosHeapNode*)(UINTPTR)(best->data + alignSize);：计算出新的节点的地址，该节点位于原节点的空闲空间之后，用于存放剩余的内存块。
node->used = 0;：将新节点标记为未使用。
node->size = best->size - alignSize - sizeof(struct LosHeapNode);：设置新节点的大小为原节点大小减去已分配内存大小和节点元数据大小的剩余空间。
node->prev = best;：设置新节点的前驱节点为原节点。
接下来的条件判断和操作用于更新堆管理器中的节点关系，确保堆的连续性。
最后，best->size = alignSize;：更新原节点的大小为已分配大小，表示原节点存放了分配的内存块。*/
if ((best->size - alignSize) > sizeof(struct LosHeapNode)) {
/* hole divide into 2 */
node = (struct LosHeapNode*)(UINTPTR)(best->data + alignSize);
@ -246,7 +332,11 @@ VOID *OsHeapAlloc(VOID *pool, UINT32 size)
best->size = alignSize;
}
/*这段代码可能是用于实现动态内存分配器的代码。具体来说，函数名称 SIZE_MATCH 可能代表了一种内存分配策略，即在进行内存分配时，选择最能够匹配请求大小的空闲内存块进行分配。
其中，代码中的 best 变量可能表示了符合请求大小的、最佳匹配的空闲内存块。代码将 best 的 align 属性设为 0，used 属性设为 1，表示该内存块已被使用。然后，代码通过指针 ptr 返回了该内存块的起始地址。最后，代码调用了 OsHeapStatAddUsed 函数，可能是用于统计内存分配情况的函数，将该内存块的使用信息记录到内存分配器的统计数据中。
值得注意的是，代码中可能存在一些未给出的上下文信息，因此具体含义可能需要根据上下文和相关代码进行推断和理解。*/
SIZE_MATCH:
best->align = 0;
best->used = 1;
@ -264,6 +354,15 @@ OUT:
* UINT32 boundary --- boundary the heap needs align
* Return : NULL:error, other value:the address of the memory we alloced
*/
/*这段代码是一个用于分配指定大小、指定对齐边界（alignment boundary）的内存块的函数。该函数的名称为 OsHeapAllocAlign。
代码首先进行了一些错误检查，确保传入的参数 pool 不为空、size 大于 0、boundary 大于等于 sizeof(VOID*)（VOID* 的大小，即指针大小），且 boundary 是对齐的。如果有任何一个条件不满足，则返回 NULL，表示内存分配失败。
接着，代码计算了需要分配的内存块的大小 useSize，并使用 OsHeapAlloc 函数在内存池 pool 中分配了 useSize 大小的内存块，并将其赋值给指针变量 ptr。
如果内存分配成功，则代码通过 OS_MEM_ALIGN 宏将 ptr 指针对齐到指定的边界 boundary。如果对齐后的指针地址与原始指针地址相同，则说明原始指针已经对齐，直接跳转到 OUT 标签处并返回 ptr 指针即可。否则，说明原始指针未对齐，需要在原始指针和对齐后的指针间填补一定的空隙（gap），并将 gap 的大小信息存储在对齐后的指针前 sizeof(UINTPTR) 个字节的位置。最后，代码返回对齐后的指针 alignedPtr。
需要注意的是，代码中可能存在一些未给出的宏定义和类型定义，具体含义可能需要根据上下文和相关代码进行推断和理解。*/
VOID* OsHeapAllocAlign(VOID *pool, UINT32 size, UINT32 boundary)
{
UINT32 useSize;
@ -297,7 +396,15 @@ VOID* OsHeapAllocAlign(VOID *pool, UINT32 size, UINT32 boundary)
OUT:
return ptr;
}
/*这段代码是一个用于释放内存的函数，名称为 OsHeapDoFree。该函数接收两个参数：一个是 LosHeapManager 结构体指针 heapMan，代表内存池管理器；另一个是 LosHeapNode 结构体指针 curNode，代表需要释放的内存块对应的内存池节点。
代码首先将 curNode 赋值给 node 变量，并将其 used 属性设为 0，表示该节点为未使用状态。
接着，代码使用 while 循环向前遍历链表，查找前面的空闲节点。具体来说，如果当前节点 node 的前一个节点存在且未被使用，则将 node 更新为前一个节点。这一步的目的是将 node 扩展到尽可能大的空闲区域。
然后，代码使用 while 循环向后遍历链表，查找后面的空闲节点。具体来说，代码使用 OsHeapPrvGetNext 函数获取 node 的下一个节点 next，如果 next 存在且未被使用，则将 node 和 next 合并为一个新的节点，并更新 node 的 size 属性。如果合并后的节点是链表中的最后一个节点（也就是 heapMan->tail 指向该节点），则更新 heapMan->tail 为合并后的新节点。如果 next 不存在或已经被使用，则结束循环。
需要注意的是，代码中使用了 LosHeapManager 和 LosHeapNode 两个结构体，具体属性和方法的含义可能需要根据上下文和相关代码进行推断和理解。*/
STATIC VOID OsHeapDoFree(struct LosHeapManager *heapMan, struct LosHeapNode *curNode)
{
struct LosHeapNode *node = curNode;
@ -330,6 +437,15 @@ STATIC VOID OsHeapDoFree(struct LosHeapManager *heapMan, struct LosHeapNode *cur
* VOID* ptr --- the pointer of heap memory we want to free
* Return : 1:success 0:error
*/
/*这段代码是用于释放指定内存块的函数 OsHeapFree。该函数接收两个参数：一个是 VOID 类型指针 pool，代表内存池；另一个是 const VOID 类型指针 ptr，代表需要释放的内存块的起始地址。
代码首先声明了一些变量和结构体指针，其中 node 是一个 LosHeapNode 结构体指针，用于表示需要释放的内存块对应的内存池节点。gapSize 是一个 UINT32 类型变量，用于记录内存块前面的空隙大小，ret 是一个 BOOL 类型变量，用于表示内存是否成功释放。
接着，代码通过将传入的 ptr 指针往前移动 sizeof(UINTPTR) 个字节，找到真正的内存块地址，并将其赋值给 ptr 变量。然后，代码判断 ptr 所指向的内存块地址是否在内存池的范围内，如果不在范围内，则返回 FALSE。
接下来，代码使用 ((struct LosHeapNode *)ptr) - 1 计算出内存块对应的内存池节点的地址，并将其赋值给 node 变量。然后，代码检查该节点是否已经被使用，以及它是否是链表中的一个节点。如果检查不通过，则将 ret 设置为 FALSE，并跳转到 OUT 标签处。
最后，代码调用 OsHeapStatDecUsed 函数将内存池管理器中 used 字段减一，然后调用 OsHeapDoFree 函数将 node 对应的内存块释放，并更新内存池管理器中的相关参数。最终返回 ret 表示操作是否成功。*/
BOOL OsHeapFree(VOID *pool, const VOID *ptr)
{
struct LosHeapNode *node = NULL;
@ -378,6 +494,19 @@ OUT:
* Output : status --- heap statistics
* Return : LOS_OK on success or error code on failure
*/
/*这段代码是用于获取指定内存池的统计信息的函数 OsHeapStatisticsGet。该函数接收两个参数：一个是 VOID 类型指针 pool，代表内存池；另一个是 LosHeapStatus 结构体指针 status，用于保存内存池的统计信息。
函数中首先声明了一些变量，包括 heapUsed、maxFreeNodeSize、freeNodeNum、usedNodeNum 以及结构体指针 node 和 ramHeap。其中 heapUsed 表示已用内存大小，maxFreeNodeSize 表示最大可用内存块大小，freeNodeNum 表示空闲节点数量，usedNodeNum 表示已用节点数量。
然后，代码检查传入的内存池指针是否为空，如果为空，则返回 LOS_NOK。接着，代码检查传入的结构体指针 status 是否为空，如果为空，则返回 LOS_NOK。
之后，代码使用 sizeof(struct LosHeapManager) 计算出内存池管理器头部占用的空间大小，并将其加到 heapUsed 变量中。
接下来，代码使用指针 node 遍历整个内存池的节点链表，对每个节点进行处理。如果该节点已被使用，则将其大小和节点头部大小相加，并将结果累加到 heapUsed 中，并将 usedNodeNum 加一。否则，如果该节点未被使用，则更新 maxFreeNodeSize 和 freeNodeNum 的值。
最后，代码检查 heapUsed 是否超过了内存池总大小，如果超过，则返回 LOS_NOK。否则，将统计信息保存到结构体指针 status 中，并返回 LOS_OK。
需要注意的是，如果系统开启了 LOSCFG_MEM_TASK_STAT 宏定义，则代码还会更新 usageWaterLine 字段的值。*/
UINT32 OsHeapStatisticsGet(VOID *pool, LosHeapStatus *status)
{
UINT32 heapUsed = 0;
@ -435,6 +564,15 @@ UINT32 OsHeapStatisticsGet(VOID *pool, LosHeapStatus *status)
* Input : pool --- Pointer to the manager, to distinguish heap
* Return : max free block size
*/
/*这段代码是用于获取指定内存池中最大可用块大小的函数 OsHeapGetMaxFreeBlkSize。该函数接收一个参数：一个 VOID 类型指针 pool，代表内存池。
函数中首先声明了一些变量，包括 size、temp、结构体指针 node 和 ramHeap。其中 size 表示最大可用块大小，temp 是一个临时变量，用于保存当前节点的大小。
然后，代码检查传入的内存池指针是否为空，如果为空，则返回 LOS_NOK。
之后，代码使用指针 node 遍历整个内存池的节点链表，对每个节点进行处理。如果该节点未被使用，则将其大小保存到 temp 变量中。如果 temp 的值比 size 大，则更新 size 的值为 temp。
最后，函数返回 size 变量的值，即内存池中最大可用块的大小。*/
UINT32 OsHeapGetMaxFreeBlkSize(VOID *pool)
{
UINT32 size = 0;

152
src/kernel/base/mem/bestfit_little/los_memory.c
Unescape View File

@ -41,18 +41,40 @@ extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#define POOL_ADDR_ALIGNSIZE 64
#define POOL_ADDR_ALIGNSIZE 64//是一个宏，表示内存池地址对齐的大小，值为64。
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_memSpin);
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_memSpin);//是一个修饰符，用于指定变量所属的段（section）为.bss.init，该变量在程序运行前会被初始化为0。
//是一个宏，用于初始化自旋锁变量g_memSpin。
UINT8 *m_aucSysMem0 = (UINT8 *)NULL;
UINT8 *m_aucSysMem1 = (UINT8 *)NULL;
__attribute__((section(".data.init"))) UINTPTR g_sys_mem_addr_end;
UINT8 *m_aucSysMem0 = (UINT8 *)NULL;//是一个指向UINT8类型的指针变量，初始值为NULL。
UINT8 *m_aucSysMem1 = (UINT8 *)NULL;//是一个指向UINT8类型的指针变量，初始值为NULL。
__attribute__((section(".data.init"))) UINTPTR g_sys_mem_addr_end;//是一个UINTPTR类型的变量，位于.data.init段，用于记录系统内存地址的末尾位置。
#ifdef LOSCFG_EXC_INTERACTION
__attribute__((section(".data.init"))) UINTPTR g_excInteractMemSize = 0;
#ifdef LOSCFG_EXC_INTERACTION//表示如果定义了宏LOSCFG_EXC_INTERACTION，则编译以下代码块。
__attribute__((section(".data.init"))) UINTPTR g_excInteractMemSize = 0;//是一个UINTPTR类型的变量，位于.data.init段，用于记录异常交互内存的大小，初始值为0。
#endif
/*这段代码是一个函数LOS_MemInit()的实现，用于初始化内存池。
LITE_OS_SEC_TEXT_INIT 是一个修饰符，用于指定函数所属的段（section）为.text.init，表示该函数在程序运行前会被初始化。
函数参数：
pool 是一个指向内存池的指针，用于存储分配的内存块。
size 是内存池的大小。
函数内部逻辑：
首先，函数会对传入的参数进行检查。如果pool为空指针或size小于等于sizeof(struct LosHeapManager)（一种内部结构的大小），则函数直接返回错误码LOS_NOK。
接下来，函数会检查pool和size是否按照OS_MEM_ALIGN_SIZE（内存对齐大小）进行对齐。如果没有对齐，则打印警告信息，并将size调整为对齐后的大小。
然后，函数会获取并保存当前的中断状态，以防止在初始化过程中发生中断。
接着，函数调用OsMemMulPoolInit()初始化多内存池管理器，如果初始化失败，则跳转到OUT标签处。
如果多内存池管理器初始化成功，函数继续调用OsHeapInit()初始化堆管理器。如果堆管理器初始化失败，则先释放多内存池，然后跳转到OUT标签处。
最后，函数调用OsSlabMemInit()初始化 Slab 内存管理器，并将返回值设置为成功的状态码LOS_OK。
在OUT标签处，函数会解锁之前保存的中断状态，并打印内存信息请求的跟踪日志。
最终，函数返回初始化结果，可能是LOS_NOK表示失败，或者LOS_OK表示成功。
这段代码主要实现了内存池的初始化逻辑，包括多内存池管理器、堆管理器和 Slab 内存管理器的初始化。*/
LITE_OS_SEC_TEXT_INIT UINT32 LOS_MemInit(VOID *pool, UINT32 size)
{
UINT32 ret = LOS_NOK;
@ -103,6 +125,21 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsMemExcInteractionInit(UINTPTR memStart)
* Description : Initialize Dynamic Memory pool
* Return : LOS_OK on success or error code on failure
*/
/*这段代码是一个条件编译块，当定义了宏LOSCFG_EXC_INTERACTION时才会被编译。
LITE_OS_SEC_TEXT_INIT 是一个修饰符，用于指定函数所属的段（section）为.text.init，表示该函数在程序运行前会被初始化。
函数参数：
memStart 是一个无符号整数指针，表示内存起始地址。
函数内部逻辑：
首先，函数将全局变量m_aucSysMem0指向memStart，即将系统内存的起始地址设为memStart。
然后，函数将全局变量g_excInteractMemSize设置为宏定义EXC_INTERACT_MEM_SIZE的值，表示异常交互内存区域的大小。
接下来，函数调用LOS_MemInit()函数，将m_aucSysMem0和g_excInteractMemSize作为参数进行内存初始化操作，并将返回结果保存在变量ret中。
最后，函数打印一条信息，包含异常交互内存的地址和大小，并将初始化结果ret作为返回值返回。
这段代码主要是用于初始化异常交互内存，通过调用LOS_MemInit()函数来初始化系统内存，并打印初始化信息。条件编译的目的是根据是否定义了LOSCFG_EXC_INTERACTION宏来控制代码的编译和执行。*/
LITE_OS_SEC_TEXT_INIT UINT32 OsMemSystemInit(UINTPTR memStart)
{
UINT32 ret;
@ -121,6 +158,18 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsMemSystemInit(UINTPTR memStart)
* Description : print heap information
* Input : pool --- Pointer to the manager, to distinguish heap
*/
/*这段代码是用于打印内存池（pool）信息的函数，接收一个pool指针作为参数。
函数参数：
pool 是一个指向内存池的指针，用于获取内存池的信息。
函数内部逻辑：
首先，函数将传入的pool指针转换为LosHeapManager结构体类型的指针，并赋值给变量heapMan。
然后，函数定义了一个LosHeapStatus类型的变量status，用于保存堆管理器的状态信息。
接着，函数调用OsHeapStatisticsGet()函数获取堆管理器的状态信息，并将其保存在status变量中。如果函数返回错误码LOS_NOK，则函数直接返回。
最后，函数打印一条包含内存池信息的日志信息，包括内存池地址、内存池大小、已使用内存大小、空闲内存大小、最大空闲节点大小、已分配节点数量和空闲节点数量。
这段代码主要是用于获取内存池的状态信息，并打印到控制台或日志文件中，方便调试和排查内存泄漏等问题。*/
VOID OsMemInfoPrint(const VOID *pool)
{
struct LosHeapManager *heapMan = (struct LosHeapManager *)pool;
@ -136,6 +185,20 @@ VOID OsMemInfoPrint(const VOID *pool)
status.usedNodeNum, status.freeNodeNum);
}
/*这段代码是用于内存分配的函数，可以从指定的内存池中分配一块指定大小的内存。
函数参数：
pool 是一个指向内存池的指针，用于从该内存池中分配内存。
size 是需要分配的内存大小。
函数内部逻辑：
首先，函数定义了一个空指针ptr，用于保存分配到的内存块地址。
然后，函数检查传入的参数，如果pool为空或者size为0，则直接返回空指针。
接着，函数锁住中断，调用OsSlabMemAlloc()函数尝试从内存池的SLAB分配器中获取一块指定大小的内存。如果分配成功，则将返回的内存地址保存在ptr中。
如果从SLAB分配器中分配内存失败，则调用OsHeapAlloc()函数从堆内存中分配一块指定大小的内存，并将返回的内存地址保存在ptr中。
最后，函数解锁中断，记录内存分配操作的追踪日志，并返回分配到的内存地址。
这段代码主要是用于从内存池中分配内存，首先尝试从SLAB分配器中获取内存，如果失败则从堆内存中获取。在获取内存时还记录了内存分配操作的追踪日志，方便调试和内存优化。*/
LITE_OS_SEC_TEXT VOID *LOS_MemAlloc(VOID *pool, UINT32 size)
{
VOID *ptr = NULL;
@ -158,6 +221,19 @@ LITE_OS_SEC_TEXT VOID *LOS_MemAlloc(VOID *pool, UINT32 size)
return ptr;
}
/*这段代码是用于按指定对齐边界分配内存的函数，可以从指定的内存池中分配一块指定大小、按指定对齐边界对齐的内存。
函数参数：
pool 是一个指向内存池的指针，用于从该内存池中分配内存。
size 是需要分配的内存大小。
boundary 是需要对齐的边界大小。返回的内存地址将会是该边界的整数倍。
函数内部逻辑：
首先，函数定义了一个空指针ptr，用于保存分配到的内存块地址。
然后，函数锁住中断，调用OsHeapAllocAlign()函数从堆内存中按指定对齐边界分配一块指定大小的内存。如果分配成功，则将返回的内存地址保存在ptr中。
最后，函数解锁中断，记录内存分配操作的追踪日志，并返回分配到的内存地址。
这段代码主要是用于从内存池中按指定对齐边界分配内存，只能在堆内存上操作。在分配内存时还记录了内存分配操作的追踪日志，方便调试和内存优化。*/
LITE_OS_SEC_TEXT VOID *LOS_MemAllocAlign(VOID *pool, UINT32 size, UINT32 boundary)
{
VOID *ptr = NULL;
@ -171,6 +247,14 @@ LITE_OS_SEC_TEXT VOID *LOS_MemAllocAlign(VOID *pool, UINT32 size, UINT32 boundar
return ptr;
}
/*这段代码是用于重新分配内存大小的函数，主要有以下几个步骤：
首先判断需要重新分配大小的指针ptr是否为空，如果为空，说明需要分配一块新的内存，直接调用LOS_MemAlloc()函数从内存池中分配一块指定大小的内存并返回。
如果需要重新分配大小的指针ptr不为空且所需大小为0，则将该指针对应的内存块释放掉。
如果需要重新分配大小的指针ptr不为空且所需大小非0，则需要从堆内存中分配一块新的内存，并将原内存中的数据拷贝到新内存中。这里在拷贝数据之前，需要先判断原内存地址是否合法。具体方法是通过OsSlabMemCheck()函数检查该指针是否属于内存池中的某个内存块，若是，则复制原内存中的数据；否则，根据原内存指针前面存储的一个整数值（表示实际内存块的大小和对齐状态）找到真正的内存块，再进行内存拷贝。
将原内存块释放掉，返回分配到的新内存地址。
这段代码的作用是实现重新分配内存大小的功能，可以对已经分配的内存进行扩展或缩小。在实现过程中，需要考虑到原内存块中已经存储的数据，避免无意义的内存拷贝操作。*/
VOID *LOS_MemRealloc(VOID *pool, VOID *ptr, UINT32 size)
{
VOID *retPtr = NULL;
@ -228,6 +312,15 @@ VOID *LOS_MemRealloc(VOID *pool, VOID *ptr, UINT32 size)
return retPtr;
}
/*这段代码是用于释放内存的函数，主要有以下几个步骤：
首先判断内存池指针pool和需要释放的内存指针mem是否为空，如果其中任意一个为空，则返回错误码LOS_NOK表示释放失败。
获取并保存当前的中断状态，以便后续恢复。
调用OsSlabMemFree()函数尝试从内存池中释放指定的内存块。若成功释放，则将返回值设置为TRUE，否则继续执行下一步。
如果调用OsSlabMemFree()函数失败，说明该内存块不是由内存池分配的，需要调用OsHeapFree()函数尝试从堆内存中释放指定的内存块。同样，若成功释放，则将返回值设置为TRUE，否则返回值保持为FALSE。
恢复之前保存的中断状态。
根据最终的返回值，如果为TRUE，则返回成功码LOS_OK，否则返回失败码LOS_NOK。
这段代码的作用是实现内存的释放功能。首先尝试从内存池中释放内存，如果失败，则再尝试从堆内存中释放内存。通过这两种方式，可以确保能够释放从内存池或堆中分配的内存块。*/
LITE_OS_SEC_TEXT UINT32 LOS_MemFree(VOID *pool, VOID *mem)
{
BOOL ret = FALSE;
@ -250,6 +343,17 @@ LITE_OS_SEC_TEXT UINT32 LOS_MemFree(VOID *pool, VOID *mem)
return (ret == TRUE ? LOS_OK : LOS_NOK);
}
/*这段代码是用于获取内存池状态信息的函数，主要有以下几个步骤：
首先判断内存池指针pool和状态信息指针status是否为空，如果其中任意一个为空，则返回错误码LOS_NOK表示获取失败。
声明一个LosHeapStatus结构体类型的变量heapStatus，用于保存堆内存的状态信息。
声明一个错误码变量err和一个中断状态变量intSave。
获取并保存当前的中断状态，以便后续恢复。
调用OsHeapStatisticsGet()函数获取指定内存池的堆内存状态信息，将结果保存在heapStatus中。如果返回错误码不等于LOS_OK，则表示获取失败，释放锁并返回错误码LOS_NOK。
将获取到的堆内存状态信息赋值给传入的status参数，包括总使用大小、总空闲大小、最大空闲节点大小、已使用节点数量和空闲节点数量。
如果配置了任务内存统计，则还会将使用的峰值赋值给status的uwUsageWaterLine字段。
释放锁并返回成功码LOS_OK。
这段代码的作用是获取指定内存池的状态信息，包括已使用的内存大小、空闲的内存大小、最大空闲节点的大小等。通过这些状态信息，可以了解内存池的使用情况，并进行相应的优化和管理。*/
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemInfoGet(VOID *pool, LOS_MEM_POOL_STATUS *status)
{
LosHeapStatus heapStatus;
@ -282,6 +386,15 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemInfoGet(VOID *pool, LOS_MEM_POOL_STATUS *st
return LOS_OK;
}
/*这段代码是用于获取指定内存池已使用内存大小的函数，主要有以下几个步骤：
首先判断内存池指针pool是否为空，如果为空，则返回错误码OS_NULL_INT表示获取失败。
声明一个LosHeapStatus结构体类型的变量heapStatus，用于保存堆内存的状态信息。
声明一个错误码变量err和一个中断状态变量intSave。
获取并保存当前的中断状态，以便后续恢复。
调用OsHeapStatisticsGet()函数获取指定内存池的堆内存状态信息，将结果保存在heapStatus中。如果返回错误码不等于LOS_OK，则表示获取失败，释放锁并返回错误码OS_NULL_INT。
释放锁并返回堆内存的总使用大小。
这段代码的作用是获取指定内存池已使用的内存大小。通过该函数可以了解内存池的已使用情况，以便进行相应的管理和优化。*/
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemTotalUsedGet(VOID *pool)
{
LosHeapStatus heapStatus;
@ -303,6 +416,13 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemTotalUsedGet(VOID *pool)
return heapStatus.totalUsedSize;
}
/*这段代码是用于获取指定内存池的大小的函数，主要有以下几个步骤：
首先判断内存池指针pool是否为空，如果为空，则返回错误码OS_NULL_INT表示获取失败。
声明一个LosHeapManager结构体类型的指针变量heapManager，用于保存内存池的管理信息。
将传入的内存池指针转换为LosHeapManager类型的指针，并将结果保存在heapManager中。
返回内存池的大小，即heapManager->size。
这段代码的作用是获取指定内存池的大小。通过该函数可以了解内存池的大小，以便进行相应的管理和优化。*/
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemPoolSizeGet(const VOID *pool)
{
struct LosHeapManager *heapManager = NULL;
@ -315,6 +435,14 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemPoolSizeGet(const VOID *pool)
return heapManager->size;
}
/*这段代码是用于对指定内存池进行完整性检查的函数，主要有以下几个步骤：
首先判断内存池指针pool是否为空，如果为空，则返回错误码OS_NULL_INT表示检查失败。
声明一个中断状态变量intSave和一个无符号整型变量ret用于保存检查结果。
获取并保存当前的中断状态，以便后续恢复。
调用OsHeapIntegrityCheck()函数对指定的内存池进行完整性检查，并将检查结果保存在ret中。如果返回的结果不为0，则表示检查失败。
释放锁并返回检查结果。
这段代码的作用是对指定的内存池进行完整性检查，以确保内存池中的数据没有被破坏或溢出。通过该函数可以及时发现内存池中的问题，并采取相应的措施进行修复或处理。*/
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemIntegrityCheck(VOID *pool)
{
UINT32 intSave;
@ -331,6 +459,16 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MemIntegrityCheck(VOID *pool)
return ret;
}
/*这段代码是用于对多个内存池进行完整性检查的函数，主要有以下几个步骤：
首先调用LOS_MemIntegrityCheck()函数对系统内存池m_aucSysMem1进行完整性检查，并判断返回值是否为LOS_OK。
如果检查通过，则在控制台输出一条信息表示检查成功，并在需要时将该信息写入异常信息缓冲区。
如果系统内存池检查未通过，则不进行任何处理。
如果宏定义LOSCFG_EXC_INTERACTION被定义，则继续执行下面的代码，否则直接结束函数。
调用LOS_MemIntegrityCheck()函数对异常交互内存池m_aucSysMem0进行完整性检查，并判断返回值是否为LOS_OK。
如果检查通过，则在控制台输出一条信息表示检查成功，并在需要时将该信息写入异常信息缓冲区。
如果异常交互内存池检查未通过，则不进行任何处理。
这段代码的作用是对多个内存池进行完整性检查，以确保内存池中的数据没有被破坏或溢出。通过该函数可以及时发现内存池中的问题，并采取相应的措施进行修复或处理。*/
VOID OsMemIntegrityMultiCheck(VOID)
{
if (LOS_MemIntegrityCheck(m_aucSysMem1) == LOS_OK) {

25
src/kernel/base/mem/bestfit_little/los_memory_internal.h
Unescape View File

@ -42,13 +42,18 @@
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
//用于将指定的大小 sz 进行对齐，返回对齐后的大小。它使用 HEAP_ALIGN 宏定义来指定对齐的字节数，通过将 sz 加上 HEAP_ALIGN - 1，然后按位取反与运算（&）来实现向上对齐。
#define ALIGNE(sz) (((sz) + HEAP_ALIGN - 1) & (~(HEAP_ALIGN - 1)))
//用于将指定的 value 进行 align 字节对齐，返回对齐后的值。它将 value 转换为 UINT32 类型，并将其与 align - 1 按位取反与运算，即将 value 向上舍入到最近的 align 的倍数。
#define OS_MEM_ALIGN(value, align) (((UINT32)(UINTPTR)(value) + (UINT32)((align) - 1)) & \
(~(UINT32)((align) - 1)))
//用于表示对齐标志的宏定义，其值为 0x80000000。
#define OS_MEM_ALIGN_FLAG 0x80000000
//用于设置对齐标志的宏定义，将传入的 align 参数按位或运算与 OS_MEM_ALIGN_FLAG 进行组合。
#define OS_MEM_SET_ALIGN_FLAG(align) ((align) = ((align) | OS_MEM_ALIGN_FLAG))
//用于获取对齐标志的宏定义，将传入的 align 参数与 OS_MEM_ALIGN_FLAG 进行按位与运算，得到对齐标志。
#define OS_MEM_GET_ALIGN_FLAG(align) ((align) & OS_MEM_ALIGN_FLAG)
//用于获取对齐间隙大小的宏定义，将传入的 align 参数与 ~OS_MEM_ALIGN_FLAG 进行按位与运算，得到去除对齐标志后的值。
#define OS_MEM_GET_ALIGN_GAPSIZE(align) ((align) & (~OS_MEM_ALIGN_FLAG))
typedef struct tagLosHeapStatus {
@ -60,8 +65,12 @@ typedef struct tagLosHeapStatus {
#ifdef LOSCFG_MEM_TASK_STAT
UINT32 usageWaterLine;
#endif
} LosHeapStatus;
} LosHeapStatus;//结构体：描述了内存堆的状态信息，包括总共使用的大小、总共空闲的大小、最大空闲节点的大小、已用节点数和空闲节点数等字段。
/*结构体：描述了内存堆中的每个节点，包括前一个节点指针、任务 ID、节点大小、
是否已经被使用、是否需要对齐等字段。这里使用了位域来节省空间，
并且使用了一个长度为 0 的数组 data[0] 来占位，
方便动态分配内存。*/
struct LosHeapNode {
struct LosHeapNode *prev;
#ifdef LOSCFG_MEM_TASK_STAT
@ -73,12 +82,12 @@ struct LosHeapNode {
UINT8 data[0];
};
extern BOOL OsHeapInit(VOID *pool, UINT32 size);
extern VOID* OsHeapAlloc(VOID *pool, UINT32 size);
extern VOID* OsHeapAllocAlign(VOID *pool, UINT32 size, UINT32 boundary);
extern BOOL OsHeapFree(VOID *pool, const VOID* ptr);
extern UINT32 OsHeapStatisticsGet(VOID *pool, LosHeapStatus *status);
extern UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap);
extern BOOL OsHeapInit(VOID *pool, UINT32 size);//函数声明：用于初始化内存池，即将一块内存空间转化为一个内存堆，并返回是否初始化成功。
extern VOID* OsHeapAlloc(VOID *pool, UINT32 size);//函数声明：用于在内存堆上分配一块指定大小的内存，并返回分配到的内存地址。
extern VOID* OsHeapAllocAlign(VOID *pool, UINT32 size, UINT32 boundary);//函数声明：用于在内存堆上分配一块指定大小并且按照给定对齐边界对齐的内存，并返回分配到的内存地址。
extern BOOL OsHeapFree(VOID *pool, const VOID* ptr);//函数声明：用于释放内存堆中的指定内存地址所对应的节点，返回是否释放成功。
extern UINT32 OsHeapStatisticsGet(VOID *pool, LosHeapStatus *status);//函数声明：用于获取内存堆的状态信息，并将其保存在传入的 LosHeapStatus 结构体中，返回获取到的信息字节数。
extern UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap);//函数声明：用于检查整个内存堆的完整性，即检查是否存在内存泄漏或内存重叠等问题。
#ifdef __cplusplus
#if __cplusplus

54
src/kernel/base/mem/common/memstat/los_memstat.c
Unescape View File

@ -39,6 +39,15 @@ extern "C" {
#define MIN_TASK_ID(x, y) ((x) > (y) ? (y) : (x))
#define MAX_MEM_USE(x, y) ((x) > (y) ? (x) : (y))
/*这段代码是一个函数OsMemstatTaskUsedInc的实现，用于更新内存统计信息。
代码首先获取任务ID的最小值，确保不越界。然后通过stat参数获取到任务内存统计数组taskMemstats。
接下来，代码将usedSize参数累加到对应任务的memUsed字段上，表示该任务使用的内存增加了usedSize字节。然后使用MAX_MEM_USE宏更新该任务的内存峰值，即将当前的memUsed值与memPeak进行比较，取较大值作为新的memPeak值。
最后，代码将usedSize参数累加到整体内存统计信息stat的memTotalUsed字段上，表示系统整体使用的内存增加了usedSize字节。同样地，使用MAX_MEM_USE宏更新整体内存的峰值。
这段代码的作用是在任务执行过程中，根据实际使用的内存大小更新任务和整体的内存统计信息。*/
LITE_OS_SEC_TEXT_MINOR VOID OsMemstatTaskUsedInc(Memstat *stat, UINT32 usedSize, UINT32 taskId)
{
UINT32 record = MIN_TASK_ID(taskId, TASK_NUM - 1);
@ -51,6 +60,13 @@ LITE_OS_SEC_TEXT_MINOR VOID OsMemstatTaskUsedInc(Memstat *stat, UINT32 usedSize,
stat->memTotalPeak = MAX_MEM_USE(stat->memTotalPeak, stat->memTotalUsed);
}
/*这段代码是一个函数OsMemstatTaskUsedDec的实现，用于更新内存统计信息。
代码首先获取任务ID的最小值，确保不越界。然后通过stat参数获取到任务内存统计数组taskMemstats。
接下来，代码判断当前任务使用的内存是否小于要释放的内存usedSize，如果是，则打印一条信息并直接返回。否则，将usedSize从对应任务的memUsed字段上减去，表示该任务使用的内存减少了usedSize字节。然后将usedSize从整体内存统计信息stat的memTotalUsed字段上减去，表示系统整体使用的内存减少了usedSize字节。
这段代码的作用是在任务执行过程中，根据实际释放的内存大小更新任务和整体的内存统计信息。如果当前任务使用的内存小于要释放的内存大小，则说明存在内存释放错误，打印一条信息以便调试。*/
LITE_OS_SEC_TEXT_MINOR VOID OsMemstatTaskUsedDec(Memstat *stat, UINT32 usedSize, UINT32 taskId)
{
UINT32 record = MIN_TASK_ID(taskId, TASK_NUM - 1);
@ -66,6 +82,15 @@ LITE_OS_SEC_TEXT_MINOR VOID OsMemstatTaskUsedDec(Memstat *stat, UINT32 usedSize,
stat->memTotalUsed -= usedSize;
}
/*这段代码是一个函数OsMemstatTaskClear的实现，用于清除任务的内存统计信息。
代码首先获取任务ID的最小值，确保不越界。然后通过stat参数获取到任务内存统计数组taskMemstats。
接下来，代码判断当前任务使用的内存是否为0，如果不为0，则打印一条信息，说明在删除任务时该任务仍有未释放的内存。
然后，将对应任务的memUsed字段和memPeak字段都设置为0，表示清除该任务的内存使用和内存峰值记录。
这段代码的作用是在删除任务时，清除该任务的内存统计信息，并在必要时打印警告信息以提醒开发者注意内存释放的完整性。*/
LITE_OS_SEC_TEXT_MINOR VOID OsMemstatTaskClear(Memstat *stat, UINT32 taskId)
{
UINT32 record = MIN_TASK_ID(taskId, TASK_NUM - 1);
@ -80,6 +105,13 @@ LITE_OS_SEC_TEXT_MINOR VOID OsMemstatTaskClear(Memstat *stat, UINT32 taskId)
taskMemstats[record].memPeak = 0;
}
/*这段代码是一个函数OsMemstatTaskUsage的实现，用于获取指定任务的内存使用量。
代码首先获取任务ID的最小值，确保不越界。然后通过stat参数获取到任务内存统计数组taskMemstats。
接下来，代码返回指定任务的memUsed字段，即该任务当前使用的内存量。
这段代码的作用是获取指定任务的内存使用量，可以用于监控和调试任务的内存消耗情况。*/
LITE_OS_SEC_TEXT_MINOR UINT32 OsMemstatTaskUsage(const Memstat *stat, UINT32 taskId)
{
UINT32 record = MIN_TASK_ID(taskId, TASK_NUM - 1);
@ -88,6 +120,17 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsMemstatTaskUsage(const Memstat *stat, UINT32 tas
return taskMemstats[record].memUsed;
}
/*这段代码是一个函数OsMemTaskUsage的实现，用于获取指定任务在系统内所有内存池中的内存使用量之和。
首先，代码定义了两个指针变量pool和stat，用于存储内存池信息和内存统计信息。
然后，通过判断是否开启了多内存池支持，分别处理单内存池和多内存池的情况。
如果未开启多内存池支持，则直接获取系统内存池的内存统计信息stat。最后，调用OsMemstatTaskUsage函数获取指定任务在该内存池中的内存使用量，并返回结果。
如果开启了多内存池支持，则需要遍历所有内存池，将每个内存池中指定任务的内存使用量累加起来，最终返回总和。
这段代码的作用是获取指定任务在系统内所有内存池中的内存使用量之和，可以用于监控和调试系统内存的消耗情况。*/
UINT32 OsMemTaskUsage(UINT32 taskId)
{
LosMemPoolInfo *pool = NULL;
@ -110,6 +153,17 @@ UINT32 OsMemTaskUsage(UINT32 taskId)
#endif
}
/*这段代码是一个函数OsMemTaskClear的实现，用于清除指定任务在系统内所有内存池中的内存统计信息。
首先，代码定义了两个指针变量pool和stat，用于存储内存池信息和内存统计信息。
然后，通过判断是否开启了多内存池支持，分别处理单内存池和多内存池的情况。
如果未开启多内存池支持，则直接获取系统内存池的内存统计信息stat。最后，调用OsMemstatTaskClear函数清除指定任务在该内存池中的内存统计信息。
如果开启了多内存池支持，则需要遍历所有内存池，依次获取每个内存池的内存统计信息，并调用OsMemstatTaskClear函数清除指定任务在每个内存池中的内存统计信息。
这段代码的作用是清除指定任务在系统内所有内存池中的内存统计信息，可以用于在删除任务时释放相关的内存统计记录，以确保内存统计信息的准确性。*/
VOID OsMemTaskClear(UINT32 taskId)
{
LosMemPoolInfo *pool = NULL;

54
src/kernel/base/mem/common/multipool/los_multipool.c
Unescape View File

@ -30,6 +30,17 @@
STATIC VOID *g_poolHead = NULL;
/*这段代码是一个函数OsMemMulPoolInit的实现，用于初始化多内存池。
首先，代码定义了几个变量，包括nextPool、curPool和poolEnd。其中，nextPool和curPool用于遍历内存池链表，poolEnd用于计算内存池的结束地址。
然后，通过循环遍历内存池链表，检查新的内存池是否与已有的内存池冲突。如果发现冲突，则输出错误信息并返回错误码。
接着，根据内存池链表的状态，将新的内存池插入到链表的末尾或者作为链表的头节点。
最后，设置新的内存池的下一个内存池指针为NULL，并返回成功的状态码。
这段代码的作用是初始化多内存池，将新的内存池插入到内存池链表中，并确保各个内存池之间没有冲突。多内存池的使用可以提供更灵活的内存管理能力，方便系统对不同类型的内存进行分配和释放。*/
UINT32 OsMemMulPoolInit(VOID *pool, UINT32 size)
{
VOID *nextPool = g_poolHead;
@ -58,6 +69,21 @@ UINT32 OsMemMulPoolInit(VOID *pool, UINT32 size)
return LOS_OK;
}
/*这段代码是一个函数OsMemMulPoolDeinit的实现，用于反初始化多内存池。
首先，代码定义了几个变量，包括ret、nextPool和curPool。其中，ret用于保存函数执行结果，nextPool和curPool用于遍历内存池链表。
然后，通过一个do-while循环的结构来执行具体的反初始化操作。
在循环中，首先检查传入的内存池指针是否为空，如果为空则直接退出循环。
接着，判断传入的内存池是否为链表的头节点。如果是头节点，则将链表的头指针指向下一个内存池，并返回成功的状态码。
如果不是头节点，则遍历内存池链表，寻找与传入的内存池指针相等的节点。一旦找到对应的节点，将前一个节点的next指针指向下一个节点，并返回成功的状态码。
最后，循环结束后，返回执行结果。
这段代码的作用是反初始化多内存池，从内存池链表中移除指定的内存池，并释放相关的资源。反初始化操作可以根据需要动态地增加或删除内存池，以适应系统的内存管理需求的变化。*/
UINT32 OsMemMulPoolDeinit(const VOID *pool)
{
UINT32 ret = LOS_NOK;
@ -90,12 +116,29 @@ UINT32 OsMemMulPoolDeinit(const VOID *pool)
return ret;
}
/*这段代码是函数OsMemMulPoolHeadGet的实现，用于获取多内存池链表的头节点指针。
代码很简单，直接返回全局变量g_poolHead，该变量保存了多内存池链表的头节点指针。
调用这个函数可以方便地获取多内存池链表的头节点地址，以便后续进行其他操作，比如对内存池进行遍历、查询或者修改等。*/
VOID *OsMemMulPoolHeadGet(VOID)
{
return g_poolHead;
}
/*这段代码是函数LOS_MemDeInit的实现，用于释放指定内存池的资源并进行反初始化操作。
首先，代码定义了几个变量，包括ret和intSave。其中，ret用于保存函数执行结果，intSave用于保存中断状态。
接下来，通过调用MEM_LOCK函数保存中断状态，以确保在执行反初始化操作期间不会被中断打断。
然后，调用OsMemMulPoolDeinit函数对指定的内存池进行反初始化操作，将返回结果保存到ret中。
最后，通过调用MEM_UNLOCK函数恢复之前保存的中断状态。
最终，返回执行结果。
这段代码的作用是释放指定内存池的资源，并执行反初始化操作。在释放内存池之前，使用MEM_LOCK函数保存中断状态，避免在释放内存池期间被中断打断，然后通过调用OsMemMulPoolDeinit函数执行反初始化操作。最后，使用MEM_UNLOCK函数恢复之前保存的中断状态。这样可以确保在释放内存池的过程中，不会发生竞态条件或者资源冲突的问题。*/
LITE_OS_SEC_TEXT_INIT UINT32 LOS_MemDeInit(VOID *pool)
{
UINT32 ret;
@ -108,6 +151,17 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_MemDeInit(VOID *pool)
return ret;
}
/*这段代码是函数LOS_MemPoolList的实现，用于打印多内存池链表中每个内存池的信息。
首先，代码定义了两个变量，包括nextPool和index。其中，nextPool用于保存下一个内存池的指针，index用于记录内存池的数量。
然后，通过一个while循环遍历多内存池链表，对每个内存池调用OsMemInfoPrint函数进行信息输出，并更新nextPool和index。
在循环中，先输出当前内存池的编号，然后调用OsMemInfoPrint函数输出该内存池的相关信息。
最后，返回内存池的数量。
这段代码的作用是打印多内存池链表中每个内存池的信息，便于开发人员进行调试和管理。通过遍历内存池链表，可以获取每个内存池的地址，并使用OsMemInfoPrint函数将内存池的相关信息输出到控制台上。同时，还可以统计内存池的数量，以便对内存池进行更精细的管理。*/
LITE_OS_SEC_TEXT_INIT UINT32 LOS_MemPoolList(VOID)
{
VOID *nextPool = g_poolHead;

18
src/kernel/extended/.vscode/c_cpp_properties.json vendored
Unescape View File

@ -0,0 +1,18 @@
{
"configurations": [
{
"name": "windows-gcc-x64",
"includePath": [
"${workspaceFolder}/**"
],
"compilerPath": "D:/mingw64/bin/gcc.exe",
"cStandard": "${default}",
"cppStandard": "${default}",
"intelliSenseMode": "windows-gcc-x64",
"compilerArgs": [
""
]
}
],
"version": 4
}

24
src/kernel/extended/.vscode/launch.json vendored
Unescape View File

@ -0,0 +1,24 @@
{
"version": "0.2.0",
"configurations": [
{
"name": "C/C++ Runner: Debug Session",
"type": "cppdbg",
"request": "launch",
"args": [],
"stopAtEntry": false,
"externalConsole": true,
"cwd": "h:/ruanjian/LiteOS-Reading/src/kernel/extended/perf/pmu",
"program": "h:/ruanjian/LiteOS-Reading/src/kernel/extended/perf/pmu/build/Debug/outDebug",
"MIMode": "gdb",
"miDebuggerPath": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
}
]
}

59
src/kernel/extended/.vscode/settings.json vendored
Unescape View File

@ -0,0 +1,59 @@
{
"C_Cpp_Runner.cCompilerPath": "gcc",
"C_Cpp_Runner.cppCompilerPath": "g++",
"C_Cpp_Runner.debuggerPath": "gdb",
"C_Cpp_Runner.cStandard": "",
"C_Cpp_Runner.cppStandard": "",
"C_Cpp_Runner.msvcBatchPath": "",
"C_Cpp_Runner.useMsvc": false,
"C_Cpp_Runner.warnings": [
"-Wall",
"-Wextra",
"-Wpedantic",
"-Wshadow",
"-Wformat=2",
"-Wcast-align",
"-Wconversion",
"-Wsign-conversion",
"-Wnull-dereference"
],
"C_Cpp_Runner.msvcWarnings": [
"/W4",
"/permissive-",
"/w14242",
"/w14287",
"/w14296",
"/w14311",
"/w14826",
"/w44062",
"/w44242",
"/w14905",
"/w14906",
"/w14263",
"/w44265",
"/w14928"
],
"C_Cpp_Runner.enableWarnings": true,
"C_Cpp_Runner.warningsAsError": false,
"C_Cpp_Runner.compilerArgs": [],
"C_Cpp_Runner.linkerArgs": [],
"C_Cpp_Runner.includePaths": [],
"C_Cpp_Runner.includeSearch": [
"*",
"**/*"
],
"C_Cpp_Runner.excludeSearch": [
"**/build",
"**/build/**",
"**/.*",
"**/.*/**",
"**/.vscode",
"**/.vscode/**"
],
"C_Cpp_Runner.useAddressSanitizer": false,
"C_Cpp_Runner.useUndefinedSanitizer": false,
"C_Cpp_Runner.useLeakSanitizer": false,
"C_Cpp_Runner.showCompilationTime": false,
"C_Cpp_Runner.useLinkTimeOptimization": false,
"C_Cpp_Runner.msvcSecureNoWarnings": false
}

34
src/kernel/extended/lowpower/los_lowpower.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */
/*低功耗管理*/
#include "los_lowpower_pri.h"
#ifdef LOSCFG_KERNEL_TICKLESS
#include "los_tickless_pri.h"
@ -36,10 +36,10 @@
__attribute__((section(".data"))) STATIC const PowerMgrOps *g_pmOps = NULL;
VOID OsLowpowerInit(const PowerMgrOps *pmOps)
VOID OsLowpowerInit(const PowerMgrOps *pmOps) /*初始化低功耗管理*/
{
if (pmOps == NULL) {
#ifdef LOSCFG_KERNEL_POWER_MGR
#ifdef LOSCFG_KERNEL_POWER_MGR/*是否配置了低功耗内核管理*/
PRINT_ERR("\r\n [PM] PowerMgrOps must be non-null.\n");
return;
#endif
@ -55,27 +55,27 @@ VOID OsLowpowerInit(const PowerMgrOps *pmOps)
g_pmOps = pmOps;
LOS_LowpowerHookReg(OsPowerMgrProcess);
/*注册低功耗处理函数和终端唤醒处理函数*/
LOS_IntWakeupHookReg(OsPowerMgrWakeUpFromInterrupt);
}
VOID OsPowerMgrProcess(VOID)
VOID OsPowerMgrProcess(VOID) /*执行低功耗管理的处理过程*/
{
#ifdef LOSCFG_KERNEL_POWER_MGR
#ifdef LOSCFG_KERNEL_POWER_MGR/*判断是否配置了内核低功耗管理*/
CALL_PMOPS_FUNC_VOID(process);
#else
if (g_pmOps == NULL) {
#ifdef LOSCFG_KERNEL_TICKLESS
OsTicklessOpen();
wfi();
wfi(); /*管理进程进入睡眠状态*/
#endif
} else {
CALL_PMOPS_FUNC_VOID(process);
CALL_PMOPS_FUNC_VOID(process);/*执行低功耗管理*/
}
#endif
}
VOID OsPowerMgrWakeUpFromInterrupt(UINT32 intNum)
VOID OsPowerMgrWakeUpFromInterrupt(UINT32 intNum) /*从中断唤醒处理*/
{
#ifdef LOSCFG_KERNEL_POWER_MGR
CALL_PMOPS_FUNC_VOID(resumeFromInterrupt, intNum);
@ -90,44 +90,44 @@ VOID OsPowerMgrWakeUpFromInterrupt(UINT32 intNum)
#endif
}
VOID OsPowerMgrWakeupFromReset(VOID)
VOID OsPowerMgrWakeupFromReset(VOID) /*从复位唤醒处理*/
{
CALL_PMOPS_FUNC_VOID(wakeupFromReset);
}
VOID LOS_PowerMgrChangeFreq(LosFreqMode freq)
VOID LOS_PowerMgrChangeFreq(LosFreqMode freq)/*改变系统频率*/
{
CALL_PMOPS_FUNC_VOID(changeFreq, freq);
}
VOID LOS_PowerMgrDeepSleepVoteBegin(VOID)
VOID LOS_PowerMgrDeepSleepVoteBegin(VOID)/*开始深度睡眠设置*/
{
CALL_PMOPS_FUNC_VOID(deepSleepVoteBegin);
}
VOID LOS_PowerMgrDeepSleepVoteEnd(VOID)
VOID LOS_PowerMgrDeepSleepVoteEnd(VOID)/*结束深度睡眠状态*/
{
CALL_PMOPS_FUNC_VOID(deepSleepVoteEnd);
}
VOID LOS_PowerMgrSleepDelay(UINT32 tick)
VOID LOS_PowerMgrSleepDelay(UINT32 tick)/*延迟进入睡眠状态*/
{
CALL_PMOPS_FUNC_VOID(deepSleepVoteDelay, tick);
}
VOID LOS_PowerMgrRegisterExtVoter(UINT32 (*callback)(VOID))
VOID LOS_PowerMgrRegisterExtVoter(UINT32 (*callback)(VOID))/*注册外部投票者*/
{
CALL_PMOPS_FUNC_VOID(registerExternalVoter, callback);
}
UINT32 LOS_PowerMgrGetSleepMode(VOID)
UINT32 LOS_PowerMgrGetSleepMode(VOID)/*获取睡眠模式*/
{
UINT32 ret = 0;
CALL_PMOPS_FUNC_RET(getSleepMode, ret);
return ret;
}
UINT32 LOS_PowerMgrGetDeepSleepVoteCount(VOID)
UINT32 LOS_PowerMgrGetDeepSleepVoteCount(VOID)/*获取深度睡眠的投票计数*/
{
UINT32 ret = 0;
CALL_PMOPS_FUNC_RET(getDeepSleepVoteCount, ret);

222
src/kernel/extended/lowpower/powermgr/los_lowpower_impl.c
Unescape View File

@ -44,7 +44,7 @@
#endif
#if defined(LOSCFG_KERNEL_RUNSTOP) || defined(LOSCFG_KERNEL_DEEPSLEEP)
/* Is system is up from the memory image, then this flag should be 1; else 0 */
/* 如果系统是从内存映像中启动的，则该标志应为1；否则为0。*/
#ifdef LOSCFG_AARCH64
__attribute__((section(".data"))) INT64 g_resumeFromImg = LOS_COLD_RESET;
__attribute__((section(".data"))) STATIC INT64 g_otherCoreResume = 0;
@ -55,8 +55,8 @@ __attribute__((section(".data"))) INT32 g_otherCoreResume = 0;
#ifdef LOSCFG_AARCH64
/*
* 16: The number of aligned memory,
* 34: The number of task context registers(X0~X30, SP, DAIF, NZCV)
* 16: 对齐内存的数量,
* 34: 任务上下文寄存器的数量，指寄存器的集合(X0~X30, SP, DAIF, NZCV)
*/
LITE_OS_SEC_DATA_MINOR __attribute__((aligned(16))) UINT64 g_saveSRContext[34];
/* 3: The number of available universal registers(X0, X1, X2) temporarily saved */
@ -161,24 +161,24 @@ STATIC PowerMgrRunOps g_pmRunOps = {
.postConfig = OsPostConfigDefault,
};
STATIC VOID OsLightSleepDefault(VOID)
STATIC VOID OsLightSleepDefault(VOID)/*轻量级睡眠函数，执行wfi指令，让处理器进入睡眠状态*/
{
TRACE_FUNC_CALL();
wfi();
}
STATIC VOID OsSetWakeUpTimerDefault(UINT32 sleepTick)
STATIC VOID OsSetWakeUpTimerDefault(UINT32 sleepTick)/*设置唤醒定时器，默认实现为空函数*/
{
TRACE_FUNC_CALL();
}
STATIC UINT32 OsWithrawWakeUpTimerDefault(VOID)
STATIC UINT32 OsWithrawWakeUpTimerDefault(VOID)/*撤销唤醒定时器，默认实现返回0*/
{
TRACE_FUNC_CALL();
return 0;
}
STATIC UINT32 OsGetSleepTimeDefault(VOID)
STATIC UINT32 OsGetSleepTimeDefault(VOID)/*获取当前任务休眠时间*/
{
#ifdef LOSCFG_KERNEL_TICKLESS
return OsSleepTicksGet();
@ -187,12 +187,12 @@ STATIC UINT32 OsGetSleepTimeDefault(VOID)
#endif
}
STATIC UINT32 OsSelectSleepModeDefault(UINT32 sleepTicks)
STATIC UINT32 OsSelectSleepModeDefault(UINT32 sleepTicks)/*选择合适的休眠模式*/
{
if (sleepTicks < g_pmMgr.minSleepTicks) {
return LOS_INTERMIT_NONE;
}
/*默认实现根据休眠时间和当前系统状态选择轻量级睡眠或者深度睡眠模式*/
if (g_pmMgr.deepSleepOps != NULL && sleepTicks >= g_pmMgr.minDeepSleepTicks &&
g_pmRunOps.getDeepSleepVoteCount() == 0) {
return LOS_INTERMIT_DEEP_SLEEP;
@ -201,73 +201,73 @@ STATIC UINT32 OsSelectSleepModeDefault(UINT32 sleepTicks)
return LOS_INTERMIT_LIGHT_SLEEP;
}
STATIC VOID OsChangeFreqDefault(UINT8 freq)
STATIC VOID OsChangeFreqDefault(UINT8 freq)/*改变处理器频率*/
{
(VOID)freq;
TRACE_FUNC_CALL();
}
STATIC VOID OsEnterDeepSleepDefault(VOID)
STATIC VOID OsEnterDeepSleepDefault(VOID)// 进入深度睡眠模式函数
{
TRACE_FUNC_CALL();
wfi();
}
STATIC UINT32 OsPreConfigDefault(VOID)
STATIC UINT32 OsPreConfigDefault(VOID)//电源管理模块预配置函数
{
TRACE_FUNC_CALL();
return 1;
}
STATIC VOID OsPostConfigDefault(VOID)
STATIC VOID OsPostConfigDefault(VOID)//电源管理模块后配置函数
{
}
#ifdef LOSCFG_KERNEL_DEEPSLEEP
STATIC BOOL OsCouldDeepSleepDefault(VOID)
STATIC BOOL OsCouldDeepSleepDefault(VOID)// 判断是否可以进入深度睡眠模式
{
TRACE_FUNC_CALL();
return true;
}
STATIC BOOL OsSuspendPreConfigDefault(VOID)
STATIC BOOL OsSuspendPreConfigDefault(VOID)// 休眠前的预配置函数
{
TRACE_FUNC_CALL();
return true;
}
STATIC VOID OsSuspendDeviceDefault(VOID)
STATIC VOID OsSuspendDeviceDefault(VOID)//休眠时设备挂起函数
{
TRACE_FUNC_CALL();
}
STATIC VOID OsRollBackDefault(VOID)
STATIC VOID OsRollBackDefault(VOID)//唤醒后的回滚函数
{
TRACE_FUNC_CALL();
}
STATIC VOID OsResumeDeviceDefault(VOID)
STATIC VOID OsResumeDeviceDefault(VOID)//唤醒后的设备恢复函数
{
TRACE_FUNC_CALL();
}
STATIC VOID OsResumePostConfigDefault(VOID)
STATIC VOID OsResumePostConfigDefault(VOID)//唤醒后电源管理模块后配置函数
{
TRACE_FUNC_CALL();
}
STATIC VOID OsSystemWakeupDefault(VOID)
STATIC VOID OsSystemWakeupDefault(VOID)//系统唤醒函数
{
TRACE_FUNC_CALL();
}
STATIC VOID OsResumeCallBackDefault(VOID)
STATIC VOID OsResumeCallBackDefault(VOID)//唤醒后回调函数
{
TRACE_FUNC_CALL();
}
STATIC VOID OsOtherCoreResumeDefault(VOID)
STATIC VOID OsOtherCoreResumeDefault(VOID)//其他核心唤醒函数
{
TRACE_FUNC_CALL();
}
@ -275,18 +275,18 @@ STATIC VOID OsOtherCoreResumeDefault(VOID)
STATIC VOID OsDeepSleepResume(VOID);
STATIC PowerMgrDeepSleepOps g_deepSleepOps = {
.couldDeepSleep = OsCouldDeepSleepDefault,
.systemWakeup = OsSystemWakeupDefault,
.suspendPreConfig = OsSuspendPreConfigDefault,
.suspendDevice = OsSuspendDeviceDefault,
.rollback = OsRollBackDefault,
.resumeDevice = OsResumeDeviceDefault,
.resumePostConfig = OsResumePostConfigDefault,
.resumeCallBack = OsResumeCallBackDefault,
.otherCoreResume = OsOtherCoreResumeDefault
.couldDeepSleep = OsCouldDeepSleepDefault, //判断是否可以进入深度睡眠模式的函数指针
.systemWakeup = OsSystemWakeupDefault,//唤醒函数的函数指针
.suspendPreConfig = OsSuspendPreConfigDefault,//修面前的预配置函数的函数指针
.suspendDevice = OsSuspendDeviceDefault,//设备挂起函数的函数指针
.rollback = OsRollBackDefault,//唤醒后的回滚函数的函数指针
.resumeDevice = OsResumeDeviceDefault,//设备回复函数的函数指针
.resumePostConfig = OsResumePostConfigDefault,//唤醒后电源管理模块后配置函数的函数指针
.resumeCallBack = OsResumeCallBackDefault,//唤醒后回调函数的函数指针
.otherCoreResume = OsOtherCoreResumeDefault//其他核心唤醒函数的函数指针
};
STATIC INLINE VOID OsTickResume(UINT32 sleepTicks)
STATIC INLINE VOID OsTickResume(UINT32 sleepTicks)//用于更新系统始终，根据休眠时间调整系统时钟
{
UINT32 cpuid = ArchCurrCpuid();
if (sleepTicks > g_pmMgr.sleepTime[cpuid]) {
@ -297,7 +297,7 @@ STATIC INLINE VOID OsTickResume(UINT32 sleepTicks)
OsSysTimeUpdate(sleepTicks);
}
STATIC VOID OsDeepSleepResume(VOID)
STATIC VOID OsDeepSleepResume(VOID)//深度睡眠唤醒后的处理函数
{
DEEPOPS_CALL_FUNC_VOID(resumeFromReset);
LOS_AtomicSet(&g_pmMgr.resumeSleepCores, OS_MP_CPU_ALL);
@ -305,30 +305,32 @@ STATIC VOID OsDeepSleepResume(VOID)
#ifdef LOSCFG_KERNEL_CPUP
OsSetCpuCycle(0);
#endif
//恢复设置，恢复其他核心进程
#if (LOSCFG_KERNEL_SMP == YES)
release_secondary_cores();
#endif
OsSRRestoreRegister();
}
STATIC INLINE VOID OsEnterDeepSleepMainCore(VOID)
STATIC INLINE VOID OsEnterDeepSleepMainCore(VOID)//用于主核心进入深度睡眠
{
//挂起预配置
LOS_AtomicAdd(&g_pmMgr.deepSleepCores, 1);
g_deepSleepOps.suspendPreConfig();
//是否可以进入神对睡眠判断
if (g_pmMgr.deepSleepCores == LOSCFG_KERNEL_CORE_NUM && g_deepSleepOps.couldDeepSleep()) {
g_deepSleepOps.suspendDevice();
g_pmRunOps.setWakeUpTimer(g_pmMgr.sleepTime[0]);
g_resumeFromImg = LOS_COLD_RESET;
OsSRSaveRegister();
//进入深度睡眠，进行回滚操作，保存上下文
if (g_resumeFromImg == LOS_COLD_RESET) {
g_resumeFromImg = LOS_DEEP_SLEEP_RESET;
CALL_RUN_OPS_FUNC_NO_RETURN(contextSave);
g_pmRunOps.enterDeepSleep();
g_deepSleepOps.rollback();
}
//设置唤醒定时器
g_deepSleepOps.resumeDevice();
UINT32 sleepTicks = g_pmRunOps.withdrawWakeUpTimer();
OsSysTimeUpdate(sleepTicks);
@ -342,42 +344,43 @@ STATIC INLINE VOID OsEnterDeepSleepMainCore(VOID)
LOS_AtomicSub(&g_pmMgr.deepSleepCores, 1);
}
STATIC INLINE VOID OsEnterSleepMode(VOID)
STATIC INLINE VOID OsEnterSleepMode(VOID)//进入睡眠模式，包括主核心和其他核心的不同处理
{
#ifdef LOSCFG_KERNEL_SMP
UINT32 currCpuid = ArchCurrCpuid();
if (currCpuid == 0) {
if (currCpuid == 0) { //如果是0则进入主核心深度睡眠
#endif
OsEnterDeepSleepMainCore();
#ifdef LOSCFG_KERNEL_SMP
#ifdef LOSCFG_KERNEL_SMP //如果当前核心不是主核心，则直接返回，因为其他核心的睡眠处理逻辑不在此函数中处理
return;
}
UINT32 cpuMask = 1 << currCpuid;
LOS_AtomicAdd(&g_pmMgr.deepSleepCores, 1);
OsSRSaveRegister();
OsSRSaveRegister();//保存相关寄存器状态并判断是否需要唤醒当前核心。
if (g_pmMgr.resumeSleepCores & cpuMask) {
INT32 val;
do {
do { //，将 g_pmMgr.resumeSleepCores 的值中当前核心的位清零，表示该核心已被唤醒。
val = LOS_AtomicRead(&g_pmMgr.resumeSleepCores);
} while (LOS_AtomicCmpXchg32bits(&g_pmMgr.resumeSleepCores, val & (~cpuMask), val));
g_deepSleepOps.otherCoreResume();
UINT32 sleepTicks = g_pmRunOps.withdrawWakeUpTimer();
OsTickResume(sleepTicks);
//执行其他核心的恢复操作，并从唤醒定时器中获取休眠时间，然后调用 OsTickResume 函数更新系统时钟。
} else {
if (g_pmMgr.deepSleepCores == LOSCFG_KERNEL_CORE_NUM) {
LOS_MpSchedule(1 << 0);
if (g_pmMgr.deepSleepCores == LOSCFG_KERNEL_CORE_NUM) {//如果不需要唤醒，则判断是否所有核心都进入了深度睡眠
LOS_MpSchedule(1 << 0);//调用函数选择一个核心唤醒系统
}
#ifdef LOSCFG_KERNEL_TICKLESS
OsTicklessOpen();
OsTicklessOpen();//开启节能模式
#endif
g_pmRunOps.enterLightSleep();
}
LOS_AtomicSub(&g_pmMgr.deepSleepCores, 1);
LOS_AtomicSub(&g_pmMgr.deepSleepCores, 1);//将 g_pmMgr.deepSleepCores 的值减1，表示当前核心已经处理完睡眠状态
#endif // LOSCFG_KERNEL_SMP
}
STATIC INLINE VOID OsSystemSuspend(LosIntermitMode *mode)
STATIC INLINE VOID OsSystemSuspend(LosIntermitMode *mode)//选择合适的低功耗模式（深度，轻度
{
// If enterShutdownMode is not defined, will fall through to standby mode
// If enterStandbyMode is not defined, will fall through to stop mode
@ -402,10 +405,10 @@ STATIC INLINE VOID OsSystemSuspend(LosIntermitMode *mode)
}
#endif
STATIC VOID OsLowpowerLightSleep(UINT32 mode, UINT32 cpuid, UINT32 sleepTicks)
STATIC VOID OsLowpowerLightSleep(UINT32 mode, UINT32 cpuid, UINT32 sleepTicks)//轻度睡眠中的模式调整
{
if (g_pmRunOps.preConfig != NULL) {
sleepTicks = g_pmRunOps.getSleepTime();
sleepTicks = g_pmRunOps.getSleepTime();//获取休眠时间
}
if (sleepTicks > 1) {
g_pmMgr.sleepMode[cpuid] = (mode & 0x0FF);
@ -414,18 +417,19 @@ STATIC VOID OsLowpowerLightSleep(UINT32 mode, UINT32 cpuid, UINT32 sleepTicks)
OsTicklessOpen();
#endif
if (mode == LOS_INTERMIT_LIGHT_SLEEP && g_pmRunOps.enterLightSleep != NULL) {
g_pmRunOps.enterLightSleep();
g_pmRunOps.enterLightSleep();//进入轻度睡眠
} else {
wfi();
}
} else {
g_pmMgr.sleepMode[cpuid] = LOS_INTERMIT_NONE;
g_pmMgr.sleepMode[cpuid] = LOS_INTERMIT_NONE;//等待中断事件
g_pmMgr.sleepTime[cpuid] = 0;
wfi();
}
}
STATIC VOID OsLowpowerDeepSleep(LosIntermitMode *mode, UINT32 cpuid, UINT32 sleepTicks)
//深度睡眠设置
{
#ifdef LOSCFG_KERNEL_DEEPSLEEP
if (g_pmRunOps.enterDeepSleep == NULL) {
@ -438,27 +442,31 @@ STATIC VOID OsLowpowerDeepSleep(LosIntermitMode *mode, UINT32 cpuid, UINT32 slee
OsSystemSuspend(mode);
}
#else
*mode = LOS_INTERMIT_LIGHT_SLEEP;
*mode = LOS_INTERMIT_LIGHT_SLEEP;//若不支持深度睡眠则强制进入轻度睡眠
#endif
}
STATIC VOID OsLowpowerProcess(VOID)
STATIC VOID OsLowpowerProcess(VOID)//处理系统进入低功耗模式的过程
{
#ifdef LOSCFG_KERNEL_RUNSTOP
#ifdef LOSCFG_KERNEL_RUNSTOP//检查系统是否需要在进入低功耗模式前保存系统消息
if (OsWowSysDoneFlagGet() == OS_STORE_SYSTEM) {
OsStoreSystemInfoBeforeSuspend();
}
#endif
/* Change frequency is pended, need to change the freq here. */
if ((g_pmRunOps.changeFreq != NULL)) {
if ((g_pmRunOps.changeFreq != NULL)) {//如果需要改变频率则调整切换
OsChangeFreq();
}
//禁止中断，锁住任务调度，并获取当前CPUID和休眠时间
UINT32 intSave = LOS_IntLock();
LOS_TaskLock();
RUNOPS_CALL_FUNC_VOID(preConfig);
UINT32 cpuid = ArchCurrCpuid();
UINT32 sleepTicks = g_pmRunOps.getSleepTime();
/*如果休眠时间小于等于最小休眠时间（g_pmMgr.minSleepTicks）
或者有任务请求不进入深度睡眠（LOS_PowerMgrGetDeepSleepVoteCount 返回值不为0），
则将当前 CPU 设置为不进入任何中断模式，清零休眠时间，
并调用 postConfig 函数。*/
if (sleepTicks <= g_pmMgr.minSleepTicks || LOS_PowerMgrGetDeepSleepVoteCount() != 0) {
g_pmMgr.sleepMode[cpuid] = LOS_INTERMIT_NONE;
g_pmMgr.sleepTime[cpuid] = 0;
@ -477,23 +485,23 @@ STATIC VOID OsLowpowerProcess(VOID)
sleepTicks = g_pmMgr.maxSleepCount;
}
UINT32 mode = g_pmRunOps.selectSleepMode(sleepTicks);
if (mode >= LOS_INTERMIT_DEEP_SLEEP) {
if (mode >= LOS_INTERMIT_DEEP_SLEEP) {//如果支持深度睡眠
g_pmMgr.sleepTime[cpuid] = g_pmRunOps.withdrawWakeUpTimer();
OsLowpowerDeepSleep(&mode, cpuid, sleepTicks);
}
RUNOPS_CALL_FUNC_VOID(postConfig);
if (mode < LOS_INTERMIT_DEEP_SLEEP) {
if (mode < LOS_INTERMIT_DEEP_SLEEP) {//进入轻度睡眠
OsLowpowerLightSleep(mode, cpuid, sleepTicks);
}
}
LOS_TaskUnlock();
LOS_IntRestore(intSave);
LOS_IntRestore(intSave);//解锁任务调度并恢复中断
}
STATIC VOID OsLowpowerWakeupFromReset(VOID)
STATIC VOID OsLowpowerWakeupFromReset(VOID)//处理系统从重置状态唤醒的情况
{
#ifdef LOSCFG_KERNEL_RUNSTOP
if (g_resumeFromImg == LOS_RUN_STOP_RESET) {
@ -508,7 +516,7 @@ STATIC VOID OsLowpowerWakeupFromReset(VOID)
#endif
}
STATIC VOID OsLowpowerWakeupFromInterrupt(UINT32 intNum)
STATIC VOID OsLowpowerWakeupFromInterrupt(UINT32 intNum)//用于处理系统从重置状态唤醒的情况
{
#ifdef LOSCFG_KERNEL_TICKLESS
OsTicklessUpdate(intNum);
@ -517,26 +525,27 @@ STATIC VOID OsLowpowerWakeupFromInterrupt(UINT32 intNum)
#endif
}
STATIC VOID OsChangeFreq(VOID)
STATIC VOID OsChangeFreq(VOID)//处理改变系统频率的操作
{
UINT32 freq;
BOOL ret;
do {
do {//尝试获取频率切换的自旋锁（通过原子操作实现）
//如果成功获取锁，则说明没有其他线程正在频率切换过程中，可以继续执行
ret = LOS_AtomicCmpXchg32bits(&g_pmMgr.freeLock, LOCK_ON, LOCK_OFF);
if (ret) {
return;
}
freq = (UINT32)g_pmMgr.freqPending;
freq = (UINT32)g_pmMgr.freqPending;//获取频率切换的目标频率，并进行频率切换
if (freq != (UINT32)g_pmMgr.freq) {
g_pmRunOps.changeFreq(freq);
g_pmRunOps.changeFreq(freq);//更新频率
LOS_AtomicSet(&g_pmMgr.freq, (INT32)freq);
}
LOS_AtomicSet(&g_pmMgr.freeLock, LOCK_OFF);
LOS_AtomicSet(&g_pmMgr.freeLock, LOCK_OFF);//释放自旋锁
} while (FreqHigher(g_pmMgr.freqPending, freq));
}
STATIC VOID OsLowpowerChangeFreq(LosFreqMode freq)
STATIC VOID OsLowpowerChangeFreq(LosFreqMode freq)//改变系统频率
{
TRACE_FUNC_CALL();
if (g_pmRunOps.changeFreq == NULL) {
@ -554,36 +563,36 @@ STATIC VOID OsLowpowerChangeFreq(LosFreqMode freq)
// We get a high frequency request, then change it
if (FreqHigher(g_pmMgr.freqPending, g_pmMgr.freq) && g_pmRunOps.changeFreq != NULL) {
OsChangeFreq();
OsChangeFreq();//如果目标频率高于当前频率，并且 g_pmRunOps.changeFreq 不为空，则调用 OsChangeFreq 函数进行频率切换。
}
}
STATIC VOID OsLowpowerDeepSleepVoteBegin(VOID)
STATIC VOID OsLowpowerDeepSleepVoteBegin(VOID)//开始深度睡眠投票
{
TRACE_FUNC_CALL();
LOS_AtomicInc(&g_pmMgr.sleepVoteCount);
LOS_AtomicInc(&g_pmMgr.sleepVoteCount);//用原子操作将 g_pmMgr.sleepVoteCount 加一，并断言 g_pmMgr.sleepVoteCount 大于零。
LOS_ASSERT(g_pmMgr.sleepVoteCount > 0);
}
STATIC VOID OsLowpowerDeepSleepVoteEnd(VOID)
STATIC VOID OsLowpowerDeepSleepVoteEnd(VOID)//结束深度睡眠投票
{
TRACE_FUNC_CALL();
LOS_AtomicDec(&g_pmMgr.sleepVoteCount);
LOS_AtomicDec(&g_pmMgr.sleepVoteCount);//原子操作将 g_pmMgr.sleepVoteCount 减一，并断言 g_pmMgr.sleepVoteCount 大于等于零。
LOS_ASSERT(g_pmMgr.sleepVoteCount >= 0);
}
STATIC VOID OsLowpowerDeepSleepVoteDelay(UINT32 delayTicks)
STATIC VOID OsLowpowerDeepSleepVoteDelay(UINT32 delayTicks)//延迟深度睡眠投票
{
TRACE_FUNC_CALL();
}
STATIC VOID OsLowpowerRegisterExternalVoter(LowpowerExternalVoterHandle callback)
STATIC VOID OsLowpowerRegisterExternalVoter(LowpowerExternalVoterHandle callback)//注册外部投票者
{
TRACE_FUNC_CALL();
g_pmMgr.exVoterHandle = callback;
}
STATIC UINT32 OsLowpowerGetDeepSleepVoteCount(VOID)
STATIC UINT32 OsLowpowerGetDeepSleepVoteCount(VOID)//获取深度睡眠投票数
{
if (g_pmMgr.exVoterHandle == NULL) {
return (UINT32)g_pmMgr.sleepVoteCount;
@ -593,22 +602,26 @@ STATIC UINT32 OsLowpowerGetDeepSleepVoteCount(VOID)
}
STATIC PowerMgrOps g_pmOps = {
.process = OsLowpowerProcess,
.wakeupFromReset = OsLowpowerWakeupFromReset,
.resumeFromInterrupt = OsLowpowerWakeupFromInterrupt,
.changeFreq = OsLowpowerChangeFreq,
.deepSleepVoteBegin = OsLowpowerDeepSleepVoteBegin,
.deepSleepVoteEnd = OsLowpowerDeepSleepVoteEnd,
.deepSleepVoteDelay = OsLowpowerDeepSleepVoteDelay,
.registerExternalVoter = OsLowpowerRegisterExternalVoter,
.getDeepSleepVoteCount = OsLowpowerGetDeepSleepVoteCount,
.getSleepMode = NULL,
.setSleepMode = NULL,
.process = OsLowpowerProcess, //该函数指针用于处理低功耗过程，即在进入低功耗模式前需要执行的操作
.wakeupFromReset = OsLowpowerWakeupFromReset,//该函数指针用于处理从复位状态唤醒时的操作
.resumeFromInterrupt = OsLowpowerWakeupFromInterrupt,//该函数指针用于处理从中断状态恢复时的操作。
.changeFreq = OsLowpowerChangeFreq,//该函数指针用于改变系统频率的操作，可以根据需要调整系统的工作频率
.deepSleepVoteBegin = OsLowpowerDeepSleepVoteBegin,//该函数指针用于开始深度休眠投票，即在进入深度休眠模式前需要执行的操作
.deepSleepVoteEnd = OsLowpowerDeepSleepVoteEnd,//该函数指针用于结束深度休眠投票，即在退出深度休眠模式后需要执行的操作
.deepSleepVoteDelay = OsLowpowerDeepSleepVoteDelay,//该函数指针用于处理深度休眠投票延迟的操作，可以根据需要延迟深度休眠的投票
.registerExternalVoter = OsLowpowerRegisterExternalVoter,//该函数指针用于注册外部投票者，即在系统中存在其他模块也需要参与低功耗投票时的操作
.getDeepSleepVoteCount = OsLowpowerGetDeepSleepVoteCount,//该函数指针用于获取当前深度休眠投票的数量，可以用来监控系统中参与休眠投票的模块数量
.getSleepMode = NULL,//该函数指针用于获取当前的睡眠模式，即获取系统当前是否处于睡眠状态
.setSleepMode = NULL,//该函数指针用于设置睡眠模式，即将系统设置为指定的睡眠模式
//以上提及的函数均为函数指针
};
#define FORCE_NULL_CALLBACK (void *)0x3f3f3f3f
#define ASSIGN_MEMBER(lhs, rhs, member) \
//以下定义是用于给结构体成员赋值，如果某个回调函数指针为特殊空值，则将相应的成员置为空，否则进行赋值
#define ASSIGN_MEMBER(lhs, rhs, member)
//lhs 是左操作数，表示要赋值的结构体指针；
//rhs 是右操作数，表示要赋给成员的值；
//member 是要赋值的结构体成员
do { \
if ((rhs)->member == FORCE_NULL_CALLBACK) { \
(lhs)->member = NULL; \
@ -631,16 +644,16 @@ VOID LOS_PowerMgrInit(const PowerMgrParameter *para)
const PowerMgrRunOps *runOps = NULL;
const PowerMgrDeepSleepOps *deepSleepOps = NULL;
(void)deepSleepOps;
if (para != NULL) {
if (para != NULL) { //如果para为空，则运行操作和深度睡眠操作都为空指针
runOps = &para->runOps;
#ifdef LOSCFG_KERNEL_DEEPSLEEP
deepSleepOps = &para->deepSleepOps;
#endif
g_pmMgr.minSleepTicks = para->config.minLightSleepTicks;
g_pmMgr.maxSleepCount = para->config.maxDeepSleepTicks;
g_pmMgr.minDeepSleepTicks = para->config.minDeepSleepTicks;
g_pmMgr.minSleepTicks = para->config.minLightSleepTicks;//记录了系统中需要从睡眠状态唤醒的 CPU 核心数
g_pmMgr.maxSleepCount = para->config.maxDeepSleepTicks;//用于保护电源管理模块在多线程环境下的并发访问
g_pmMgr.minDeepSleepTicks = para->config.minDeepSleepTicks;//记录自旋锁是否被释放
}
//将传入的运行操作和深度睡眠操作分别赋值给全局变量 g_pmRunOps 和 g_deepSleepOps
LOS_AtomicSet(&g_pmMgr.resumeSleepCores, 0);
LOS_SpinInit(&g_pmMgr.lock);
@ -648,25 +661,25 @@ VOID LOS_PowerMgrInit(const PowerMgrParameter *para)
// verify and assign input operators.
if (runOps != NULL) {
ASSIGN_MEMBER(&g_pmRunOps, runOps, changeFreq);
ASSIGN_MEMBER(&g_pmRunOps, runOps, enterLightSleep);
ASSIGN_MEMBER(&g_pmRunOps, runOps, changeFreq);//改变CPU频率
ASSIGN_MEMBER(&g_pmRunOps, runOps, enterLightSleep);//进入浅度睡眠
#ifdef LOSCFG_KERNEL_DEEPSLEEP
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, enterDeepSleep);
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, setWakeUpTimer);
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, withdrawWakeUpTimer);
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, enterDeepSleep);//进入深度睡眠
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, setWakeUpTimer);//设置唤醒定时器
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, withdrawWakeUpTimer);//撤销定时器
#else
ASSIGN_MEMBER(&g_pmRunOps, runOps, enterDeepSleep);
ASSIGN_MEMBER(&g_pmRunOps, runOps, setWakeUpTimer);
ASSIGN_MEMBER(&g_pmRunOps, runOps, withdrawWakeUpTimer);
#endif
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, getSleepTime);
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, selectSleepMode);
ASSIGN_MEMBER(&g_pmRunOps, runOps, preConfig);
ASSIGN_MEMBER(&g_pmRunOps, runOps, postConfig);
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, getSleepTime);//货的睡眠时间
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, selectSleepMode);//选择不同的睡眠模式
ASSIGN_MEMBER(&g_pmRunOps, runOps, preConfig);//预配置
ASSIGN_MEMBER(&g_pmRunOps, runOps, postConfig);//后配置
}
#ifdef LOSCFG_KERNEL_DEEPSLEEP
if (deepSleepOps != NULL) {
if (deepSleepOps != NULL) {//进入深度睡眠
ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, couldDeepSleep);
ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, systemWakeup);
ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, suspendPreConfig);
@ -680,4 +693,7 @@ VOID LOS_PowerMgrInit(const PowerMgrParameter *para)
#endif
// Register PowerMgr to Low-Power Framework.
LOS_LowpowerInit(&g_pmOps);
//将电源管理模块注册到低功耗框架中。
//低功耗框架是一个用于管理处理器和设备进入低功耗模式的软件框架，
//它能够最大限度地降低系统能耗，提高系统的电池寿命
}

137
src/kernel/extended/lowpower/runstop/src/los_runstop.c
Unescape View File

@ -51,22 +51,28 @@ extern "C" {
/* If core is ready for imaging */
LITE_OS_SEC_DATA_MINOR STATIC UINT32 g_sysDoneFlag[LOSCFG_KERNEL_CORE_NUM] = {
[0 ... (LOSCFG_KERNEL_CORE_NUM - 1)] = OS_NO_STORE_SYSTEM
};
}; /*标记数组状态，用来表示系统是否加载完成*/
/* Start position of flash to write image */
LITE_OS_SEC_DATA_MINOR STATIC UINTPTR g_flashImgAddr;
/*flash图像地址和大小，用于存储flash相关信息。*/
/* Start position of heap memory after carry the image from flash to memory */
LITE_OS_SEC_DATA_MINOR STATIC const VOID *g_heapMemStart = NULL;
/*初始化图像地址*/
/* Size of heap memory in image */
LITE_OS_SEC_DATA_MINOR STATIC size_t g_heapMemSize = 0;
/*初始化定义图像大小*/
#ifdef LOSCFG_EXC_INTERACTION
/* Start position of exc interaction heap memory after carry the image from flash to memory */
LITE_OS_SEC_DATA_MINOR STATIC const VOID *g_excInteractionMemStart = NULL;
/*在存储器映像从闪存复制到内存之后异常交互堆的起始位置变量*/
/* Size of exc interaction heap memory in image */
LITE_OS_SEC_DATA_MINOR STATIC size_t g_excInteractionMemSize = 0;
/*异常交互堆内存在储存器映像中的大小*/
#endif
/* Size of wow image */
LITE_OS_SEC_DATA_MINOR STATIC size_t g_wowImgSize = 0;
@ -76,15 +82,17 @@ LITE_OS_SEC_DATA_MINOR STATIC EVENT_CB_S g_suspendResumeEvent;
LITE_OS_SEC_DATA_MINOR STATIC EVENT_CB_S g_writeFlashEvent;
typedef struct {
UINTPTR memStart;
UINTPTR flashStart;
size_t memSize;
UINTPTR memStart; /*内存起始地址*/
UINTPTR flashStart; /*闪存起始地址*/
size_t memSize; /*存储空间大小*/
} FlashWriteParam;
BOOL IsImageResume(VOID)
{
return (g_resumeFromImg != LOS_COLD_RESET);
}
/*判断系统是否从存储器映像中恢复的，功能是当系统异常启动或者需要重启的时候就会从内存将其数据保存到闪存中
此函数就是判断系统是否是从存储器映像回复的，从而确定是否需要对系统状态进行恢复*/
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsDoWriteWow2Flash(FLASH_WRITE_FUNC flashWriteFunc,
const FlashWriteParam *wowSection,
@ -109,29 +117,32 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsDoWriteWow2Flash(FLASH_WRITE_FUNC flashWrit
return;
}
}
LITE_OS_SEC_TEXT_MINOR VOID OsWriteWow2Flash(VOID)
/*首先检查内存中的大小是否为0
若不为0则将wowsection、excheapsection、heapmemsection中的静态数据和代码存储在系统启动的时候将其从闪存加入到内存中*/
LITE_OS_SEC_TEXT_MINOR VOID OsWriteWow2Flash(VOID) /*根据指定的内存区域，在闪存中写入相应的数据，完成写入操作*/
{
FlashWriteParam wowSection;
FlashWriteParam excHeapSection = {0};
FlashWriteParam heapMemSection;
size_t eraseAlignSize;
size_t writeAlignSize;
FlashWriteParam heapMemSection; /*这是三种闪存内部独立的堆专用的内存区域对应的闪存写入参数*/
size_t eraseAlignSize; /*表示闪存擦除时的对齐大小*/
size_t writeAlignSize; /*闪存写入时的对齐大小*/
FLASH_WRITE_FUNC flashWriteFunc = g_runstopParam.pfFlashWriteFunc;
eraseAlignSize = g_runstopParam.uwFlashEraseAlignSize;
writeAlignSize = g_runstopParam.uwFlashWriteAlignSize;
eraseAlignSize = g_runstopParam.uwFlashEraseAlignSize; /*用来指定擦除和写入时的对齐大小，通常设置为扇区大小的整数倍*/
writeAlignSize = g_runstopParam.uwFlashWriteAlignSize; /*为了避免出现擦除或写入不规则数据的情况，
需要将操作的地址向下或向上舍入到扇区大小的整数倍
从而避免因为不规则的操作而导致数据的错误或损坏。*/
writeAlignSize = (writeAlignSize >= eraseAlignSize) ? writeAlignSize : eraseAlignSize;
if (flashWriteFunc == NULL) {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
return;
}
wowSection.memStart = (UINTPTR)&__ram_vectors_vma;
wowSection.flashStart = g_flashImgAddr;
wowSection.memStart = (UINTPTR)&__ram_vectors_vma;/*初始化wowSection，为内存中起始地址*/
wowSection.flashStart = g_flashImgAddr; /*为闪存中起始地址*/
wowSection.memSize = ((UINTPTR)&__wow_end) - ((UINTPTR)&__ram_vectors_vma);
wowSection.memSize = (wowSection.memSize + writeAlignSize - 1) & ~(writeAlignSize - 1);
/*计算了wowSection大小，通过与运算保证每次写入的数据都是整个扇区的倍数*/
#ifdef LOSCFG_EXC_INTERACTION
excHeapSection.memStart = (UINTPTR)m_aucSysMem0;
excHeapSection.flashStart = g_flashImgAddr + wowSection.memSize;
@ -152,39 +163,41 @@ LITE_OS_SEC_TEXT_MINOR VOID OsWriteWow2Flash(VOID)
g_wowImgSize = wowSection.memSize + heapMemSection.memSize + excHeapSection.memSize;
OsDoWriteWow2Flash(flashWriteFunc, &wowSection, &excHeapSection, &heapMemSection);
/*将变量传输给函数，由其实现相应的写入操作*/
}
LITE_OS_SEC_TEXT_MINOR VOID OsSystemSuspend(VOID)
LITE_OS_SEC_TEXT_MINOR VOID OsSystemSuspend(VOID) /*实现系统的挂起操作*/
{
UINT32 cpuid;
UINT32 cpuid; /*获取当前CPU的ID*/
(VOID)LOS_IntLock();
LOS_TaskLock();
cpuid = ArchCurrCpuid();
/*禁止中断并锁定任务调度器，确保在执行挂起操作期间不会被打断*/
g_sysDoneFlag[cpuid] = OS_NO_STORE_SYSTEM; /*将当前CPU的系统挂起标志设置为不需要保存系统状态*/
g_saveTsk[cpuid] = OsCurrTaskGet(); /*保存当前任务指针到savetask变量中*/
g_sysDoneFlag[cpuid] = OS_NO_STORE_SYSTEM;
g_saveTsk[cpuid] = OsCurrTaskGet();
OsSRSaveRegister();
OsSRSaveRegister(); /*保存当前CPU的寄存器状态，以便在恢复系统时能够正确恢复到挂起前的状态*/
/* If 1 core, only to save registers */
if (cpuid != 0) {
if (g_otherCoreResume != 0) {
if (cpuid != 0) { /*若此CPU部位0号内核*/
if (g_otherCoreResume != 0) { /*说明其他多核核心需要恢复运行*/
HalIrqInitPercpu();
OsTickStart();
LOS_TaskUnlock();
(VOID)LOS_IntUnLock();
return;
}
g_sysDoneFlag[cpuid - 1] = OS_STORE_SYSTEM;
g_sysDoneFlag[cpuid - 1] = OS_STORE_SYSTEM; /*需要初始化中断并启动系统时钟，并最终解锁任务调度器并恢复中断*/
while (1) {}
}
if (g_resumeFromImg) {
if (g_resumeFromImg) { /*如果是 0 号 CPU，且系统需要从镜像中恢复（g_resumeFromImg 为真）*/
OsWriteWow2Flash();
LOS_TaskUnlock();
(VOID)LOS_IntUnLock();
(VOID)LOS_EventWrite(&g_suspendResumeEvent, FLASH_IMG_SUCCESS);
} else {
/*调用 OsWriteWow2Flash 函数将数据写入闪存，并发送 FLASH_IMG_SUCCESS 事件信号，表示成功从镜像中恢复*/
} else { /*不需要从镜像中恢复*/
OsTickStart();
LOS_TaskUnlock();
(VOID)LOS_IntUnLock();
@ -194,9 +207,15 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemSuspend(VOID)
}
(VOID)LOS_EventWrite(&g_suspendResumeEvent, WAKEUP_FROM_SUSPEND);
}
/*启动系统时钟，解锁任务调度器和中断，并根据是否设置了空闲唤醒回调函数来执行相应的操作，
最后发送 WAKEUP_FROM_SUSPEND 事件信号，表示从挂起状态唤醒*/
}
LITE_OS_SEC_TEXT VOID OsWriteToFlashTask(VOID)
/*初始化了一个事件对象 g_writeFlashEvent
并且在循环中调用 LOS_EventRead 函数等待事件的发生，
并以 OR 模式和清除模式等待事件的标志位为 0x01。
一旦事件发生，它调用 OsSystemSuspend 函数将系统挂起。*/
{
(VOID)LOS_EventInit(&g_writeFlashEvent);
@ -207,6 +226,10 @@ LITE_OS_SEC_TEXT VOID OsWriteToFlashTask(VOID)
}
LITE_OS_SEC_TEXT VOID OsStoreSystemInfoBeforeSuspend(VOID)
/*根据当前 CPU 的 ID 判断是否需要挂起系统。
如果当前 CPU 不是 0 号 CPU，直接调用 OsSystemSuspend 函数挂起系统。
如果是 0 号 CPU，则调用 LOS_EventWrite 函数向事件对象 g_writeFlashEvent 发送一个事件，
唤醒 OsWriteToFlashTask 任务来执行挂起操作。*/
{
UINT32 cpuid = ArchCurrCpuid();
if (cpuid != 0) {
@ -218,6 +241,9 @@ LITE_OS_SEC_TEXT VOID OsStoreSystemInfoBeforeSuspend(VOID)
}
LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
/*是系统从挂起状态唤醒后的处理函数。*/
{
UINT32 cpuid;
errno_t err;
@ -225,7 +251,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
if (!g_resumeFromImg) {
return;
}
/*进行一些内存数据的复制操作，然后设置当前 CPU 的任务指针，*/
#ifdef LOSCFG_EXC_INTERACTION
err = memmove_s(m_aucSysMem0, g_excInteractMemSize, g_excInteractionMemStart, g_excInteractionMemSize);
if (err != EOK) {
@ -243,6 +269,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
cpuid = ArchCurrCpuid();
OsCurrTaskSet(g_saveTsk[cpuid]);
/*设置系统计数器频率。接着，它重置内存池的末尾节点，清零 BSS 区域的数据，重新初始化中断*/
/* Set system counter freq */
HalClockFreqWrite(OS_SYS_CLOCK);
dsb();
@ -270,7 +297,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
#ifdef LOSCFG_KERNEL_CPUP
OsSetCpuCycle(0);
#endif
/*并调用 OsSRRestoreRegister 函数恢复寄存器状态*/
#if (LOSCFG_KERNEL_SMP == YES)
release_secondary_cores();
#endif
@ -281,32 +308,33 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsWaitImagingDone(UINTPTR wowFlashAddr, size_t *wo
{
UINT32 ret;
g_flashImgAddr = wowFlashAddr;
(VOID)LOS_EventInit(&g_suspendResumeEvent);
g_flashImgAddr = wowFlashAddr; /*烧录的flash地址*/
(VOID)LOS_EventInit(&g_suspendResumeEvent); /*指向用于存储烧录镜像大小的变量的指针*/
// This flag will be stored into flash, and will affect the wakeup procedure when cpu is rebooting.
// 这个标志将被存储到闪存中，当 CPU 重新启动时，它将影响唤醒流程。
g_resumeFromImg = LOS_RUN_STOP_RESET;
// This flag affects the suspending procedure later,
// and will be reset depending on 'g_resumeFromImg' when cpu is rebooting.
// 这个标志会影响之后的挂起过程，并且在 CPU 重新启动时根据 'g_resumeFromImg' 的值进行重置
g_otherCoreResume = 0;
g_sysDoneFlag[LOSCFG_KERNEL_CORE_NUM - 1] = OS_STORE_SYSTEM;
g_sysDoneFlag[LOSCFG_KERNEL_CORE_NUM - 1] = OS_STORE_SYSTEM; /*表示系统状态需要被保存*/
ret = LOS_EventRead(&g_suspendResumeEvent, 0xFF, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
/*等待事件发生*/
if (wowImgSize != NULL) {
*wowImgSize = g_wowImgSize;
}
}/*保证能够在烧录完成之后正确的保存和恢复状态*/
return ret;
}
LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID)
LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID) /*将位于RAM的数据从指定位置复制到Flash存储器中*/
{
size_t size;
UINTPTR memAddr;
size_t wowSize;
size_t readAlignSize;
size_t eraseAlignSize;
size_t writeAlignSize;
size_t wowSize;/*等待复制数据的大小*/
size_t readAlignSize;/*读取对齐大小*/
size_t eraseAlignSize;/*擦除对齐大小*/
size_t writeAlignSize;/*写入对齐大小*/
/*读取所有参数的初始状态*/
UINTPTR imageFlashAddr;
FLASH_READ_FUNC flashReadFunc = g_runstopParam.pfFlashReadFunc;
@ -315,18 +343,19 @@ LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID)
eraseAlignSize = g_runstopParam.uwFlashEraseAlignSize;
writeAlignSize = g_runstopParam.uwFlashWriteAlignSize;
writeAlignSize = (writeAlignSize >= eraseAlignSize) ? writeAlignSize : eraseAlignSize;
/*计算wowsize的大小，根据对齐大小调整值*/
wowSize = ((UINTPTR)&__wow_end) - ((UINTPTR)&__ram_vectors_vma);
wowSize = (wowSize + writeAlignSize - 1) & ~(writeAlignSize - 1);
imageFlashAddr += wowSize;
/*检查memaddr是否超出了BSS段的起始地址*/
memAddr = ((UINTPTR)&__ram_vectors_vma) + wowSize;
if (memAddr >= ((UINTPTR)&__bss_start)) {
return;
}
/*计算了要复制的数据大小，在磁盘中根据对齐大小调整size*/
size = ((UINTPTR)&__int_stack_start) - memAddr;
size = (size + readAlignSize - 1) & ~(readAlignSize - 1);
/*将RAM中的数据从memaddr复制到flash存储器的imageflashaddr，进行缓存和同步操作*/
if ((flashReadFunc != NULL) && (flashReadFunc((VOID *)memAddr, imageFlashAddr, size) != 0)) {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
}
@ -336,6 +365,8 @@ LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID)
}
LITE_OS_SEC_TEXT_MINOR VOID OsRunstopParamInit(const RUNSTOP_PARAM_S *runstopParam)
/*初始化运行暂停功能所需的参数，保存在全局变量g_中，以便告诉计算机目前的系统转台
包含了运行暂停功能所需的各个回调函数和对齐大小等参数*/
{
g_runstopParam.pfIdleWakeupCallback = runstopParam->pfIdleWakeupCallback;
g_runstopParam.pfWakeupCallback = runstopParam->pfWakeupCallback;
@ -350,28 +381,31 @@ LITE_OS_SEC_TEXT_MINOR VOID OsRunstopParamInit(const RUNSTOP_PARAM_S *runstopPar
}
LITE_OS_SEC_TEXT_MINOR VOID LOS_MakeImage(RUNSTOP_PARAM_S *runstopParam)
/*用于除法运行暂停功能的操作，并根据返回值进行相应处理*/
{
UINT32 ret;
size_t imgSize;
/*检查是否需要暂停*/
if (runstopParam == NULL) {
return;
}
/*调用函数，将传入的runstopparam转换为全局变量*/
OsRunstopParamInit(runstopParam);
ret = OsWaitImagingDone(g_runstopParam.uwWowFlashAddr, &imgSize);
if (ret == WAKEUP_FROM_SUSPEND) {
/*用于等待图像转移完成，范围相应的状态码ret和图像大小imgsize*/
if (ret == WAKEUP_FROM_SUSPEND) { /*从暂停状态唤醒，并查看系统是否需要空闲唤醒回调*/
if (g_runstopParam.pfWakeupCallback != NULL) {
g_runstopParam.pfWakeupCallback();
}
OsCarryLeftScatter();
OsCarryLeftScatter(); /*将RAM中的数据复制到Flash存储器*/
PRINT_INFO("Resume ok!\n");
} else if (ret == FLASH_IMG_SUCCESS) {
} else if (ret == FLASH_IMG_SUCCESS) { /*闪存图像成功*/
if (g_runstopParam.pfImageDoneCallback != NULL) {
g_runstopParam.pfImageDoneCallback();
}
PRINT_INFO("Flash ok! Image length 0x%x\n", imgSize);
PRINT_INFO("Flash ok! Image length 0x%x\n", imgSize);/*图像转移成功，并打印图像大小*/
}
}
@ -380,8 +414,9 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsWowWriteFlashTaskCreate(VOID)
UINT32 ret;
UINT32 writeFlashTaskId;
TSK_INIT_PARAM_S taskInitParam;
/*首先对任务初始化参数进行了清零操作*/
(VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
/*设置了任务入口函数，并且制定了任务的堆栈大小，任务名和优先级*/
taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsWriteToFlashTask;
taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
taskInitParam.pcName = "WowWriteFlashTask";
@ -389,24 +424,28 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsWowWriteFlashTaskCreate(VOID)
#ifdef LOSCFG_KERNEL_SMP
taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(0);
#endif
/*创建任务，返回结果*/
ret = LOS_TaskCreate(&writeFlashTaskId, &taskInitParam);
return ret;
}
LITE_OS_SEC_TEXT_MINOR size_t OsWowImageSizeGet(VOID)
/*获取wow图像的大小，返回全局变量*/
{
return g_wowImgSize;
}
LITE_OS_SEC_TEXT_MINOR UINT32 OsWowSysDoneFlagGet(VOID)
/*获取wow系统完成的标志*/
{
UINT32 cpuid = ArchCurrCpuid();
return g_sysDoneFlag[cpuid];
}
LITE_OS_SEC_TEXT_MINOR VOID OsWowOtherCoreResume(UINT32 cpuid)
/*唤醒其他的核心*/
{
if (g_otherCoreResume == 1) {
if (g_otherCoreResume == 1) { /*全局变量的值为1则表示需要唤醒其他核心*/
OsCurrTaskSet(g_saveTsk[cpuid]);
OsSRRestoreRegister();
}

29
src/kernel/extended/lowpower/tickless/los_tickless.c
Unescape View File

@ -46,17 +46,18 @@ STATIC volatile UINT32 g_sleepTicks[LOSCFG_KERNEL_CORE_NUM] = {0};
(((GET_SYS_CLOCK()) / (g_tickPerSecond)) - (cyclesCur)) : \
((((GET_SYS_CLOCK()) / (g_tickPerSecond)) << 1) - (cyclesCur)))
LITE_OS_SEC_TEXT VOID LOS_TicklessEnable(VOID)
LITE_OS_SEC_TEXT VOID LOS_TicklessEnable(VOID) /*开启Tickless功能*/
{
g_ticklessFlag = TRUE;
/*变量表示Tickless功能的开启状态，为TRUE表示已开启，为FALSE表示已关闭。*/
}
LITE_OS_SEC_TEXT VOID LOS_TicklessDisable(VOID)
LITE_OS_SEC_TEXT VOID LOS_TicklessDisable(VOID) /*开启Tickless功能*/
{
g_ticklessFlag = FALSE;
}
LITE_OS_SEC_TEXT BOOL OsTicklessFlagGet(VOID)
LITE_OS_SEC_TEXT BOOL OsTicklessFlagGet(VOID) /*用于获取Tickless标志的状态*/
{
return g_ticklessFlag;
}
@ -64,24 +65,27 @@ LITE_OS_SEC_TEXT BOOL OsTicklessFlagGet(VOID)
LITE_OS_SEC_TEXT BOOL OsTickIrqFlagGet(VOID)
{
return g_tickIrqFlag[ArchCurrCpuid()];
/*数组表示每个核心的Tick中断标志的状态，
为TRUE表示中断正在处理中，为FALSE表示中断未处理。*/
}
LITE_OS_SEC_TEXT VOID OsTickIrqFlagSet(BOOL tickIrqFlag)
LITE_OS_SEC_TEXT VOID OsTickIrqFlagSet(BOOL tickIrqFlag) /*用于设置当前核心的时钟中断标志*/
{
g_tickIrqFlag[ArchCurrCpuid()] = tickIrqFlag;
}
LITE_OS_SEC_TEXT UINT32 OsTicklessSleepTickGet(VOID)
LITE_OS_SEC_TEXT UINT32 OsTicklessSleepTickGet(VOID) /*用于获取当前系统的睡眠计时器的数值*/
{
return g_sleepTicks[ArchCurrCpuid()];
}
LITE_OS_SEC_TEXT VOID OsTicklessSleepTickSet(UINT32 sleeptick)
LITE_OS_SEC_TEXT VOID OsTicklessSleepTickSet(UINT32 sleeptick) /*设置当前核心得到睡眠计时器的数值*/
{
g_sleepTicks[ArchCurrCpuid()] = sleeptick;
}
LITE_OS_SEC_TEXT UINT32 OsSleepTicksGet(VOID)
LITE_OS_SEC_TEXT UINT32 OsSleepTicksGet(VOID) /*函数用于获取当前需要休眠的ticks数，通过查询任务链表和软件定时器链表，
找到最小的定时器到期时间，作为休眠时长。*/
{
UINT32 tskSortLinkTicks, sleepTicks;
@ -104,7 +108,8 @@ LITE_OS_SEC_TEXT UINT32 OsSleepTicksGet(VOID)
return sleepTicks;
}
LITE_OS_SEC_TEXT VOID OsSysTimeUpdate(UINT32 sleepTicks)
LITE_OS_SEC_TEXT VOID OsSysTimeUpdate(UINT32 sleepTicks) /*用于更新系统时间，
根据休眠时长更新全局计数器和任务链表、软件定时器链表的到期时间*/
{
UINT32 intSave;
@ -127,7 +132,7 @@ LITE_OS_SEC_TEXT VOID OsSysTimeUpdate(UINT32 sleepTicks)
LOS_IntRestore(intSave);
}
VOID OsTicklessUpdate(UINT32 irqnum)
VOID OsTicklessUpdate(UINT32 irqnum) /*OsTicklessUpdate函数用于在发生中断时更新系统时间*/
{
UINT32 cycles, ticks;
UINT32 cyclesPertick;
@ -165,7 +170,8 @@ VOID OsTicklessUpdate(UINT32 irqnum)
LOS_IntRestore(intSave);
}
VOID OsTicklessStart(VOID)
VOID OsTicklessStart(VOID) /*Tickless模式的入口函数，根据休眠时长计算需要延迟的周期数，
并设置定时器的重载值，启动Tickless模式。*/
{
UINT32 intSave;
/*
@ -202,7 +208,8 @@ VOID OsTicklessStart(VOID)
return;
}
VOID OsTicklessOpen(VOID)
VOID OsTicklessOpen(VOID) /*在Tick中断处理函数中开启Tickless模式。
当Tick中断处理函数检测到Tickless标志为1时，调用该函数启动Tickless模式。*/
{
if (OsTickIrqFlagGet()) {
OsTickIrqFlagSet(0);

101
src/kernel/extended/perf/los_perf.c
Unescape View File

@ -37,10 +37,11 @@ extern "C" {
#endif /* __cplusplus */
#ifdef LOSCFG_KERNEL_PERF
STATIC Pmu *g_pmu = NULL;
STATIC PerfCB g_perfCb = {0};
STATIC Pmu *g_pmu = NULL;//用于保存当前系统中所使用的硬件性能计数器
STATIC PerfCB g_perfCb = {0};//保存了性能测量回调函数和一些测量结果数据
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_perfSpin);
//定义了一个自旋锁 g_perfSpin，用于保护性能测量模块在多线程环境下的并发访问
#define PERF_LOCK(state) LOS_SpinLockSave(&g_perfSpin, &(state))
#define PERF_UNLOCK(state) LOS_SpinUnlockRestore(&g_perfSpin, (state))
@ -55,8 +56,9 @@ STATIC INLINE UINT64 OsPerfGetCurrTime(VOID)
#endif
}
STATIC UINT32 OsPmuInit(VOID)
STATIC UINT32 OsPmuInit(VOID)//初始化性能计数器
{
//判断是否开启了计数器
#ifdef LOSCFG_PERF_HW_PMU
if (OsHwPmuInit() != LOS_OK) {
return LOS_ERRNO_PERF_HW_INIT_ERROR;
@ -77,13 +79,13 @@ STATIC UINT32 OsPmuInit(VOID)
return LOS_OK;
}
STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg)
STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg)//配置性能计数器
{
UINT32 i;
UINT32 ret;
g_pmu = OsPerfPmuGet(eventsCfg->type);
if (g_pmu == NULL) {
if (g_pmu == NULL) {//根据配置的类型获取对应的性能计数器对象
PRINT_ERR("perf config type error %u!\n", eventsCfg->type);
return LOS_ERRNO_PERF_INVALID_PMU;
}
@ -92,6 +94,7 @@ STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg)
(VOID)memset_s(&g_pmu->events, sizeof(PerfEvent), 0, sizeof(PerfEvent));
//根据配置信息设置各性能事件的参数，调用性能计数器对象的配置函数进行配置
for (i = 0; i < eventNum; i++) {
g_pmu->events.per[i].eventId = eventsCfg->events[i].eventId;
g_pmu->events.per[i].period = eventsCfg->events[i].period;
@ -109,13 +112,13 @@ STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg)
return LOS_OK;
}
STATIC VOID OsPerfPrintCount(VOID)
STATIC VOID OsPerfPrintCount(VOID)//用于打印性能计数器的统计信息
{
UINT32 index;
UINT32 intSave;
UINT32 cpuid = ArchCurrCpuid();
PerfEvent *events = &g_pmu->events;
PerfEvent *events = &g_pmu->events;//获取性能计数器对象的性能时间数组和事件数量
UINT32 eventNum = events->nr;
PERF_LOCK(intSave);
@ -123,7 +126,7 @@ STATIC VOID OsPerfPrintCount(VOID)
Event *event = &(events->per[index]);
/* filter out event counter with no event binded. */
if (event->period == 0) {
if (event->period == 0) { //事件周期
continue;
}
PRINT_EMG("[%s] eventType: 0x%x [core %u]: %llu\n", g_pmu->getName(event), event->eventId, cpuid,
@ -132,7 +135,7 @@ STATIC VOID OsPerfPrintCount(VOID)
PERF_UNLOCK(intSave);
}
STATIC INLINE VOID OsPerfPrintTs(VOID)
STATIC INLINE VOID OsPerfPrintTs(VOID)//打印时间信息
{
#ifdef LOSCFG_PERF_CALC_TIME_BY_TICK
DOUBLE time = (g_perfCb.endTime - g_perfCb.startTime) * 1.0 / LOSCFG_BASE_CORE_TICK_PER_SECOND;
@ -142,7 +145,7 @@ STATIC INLINE VOID OsPerfPrintTs(VOID)
PRINT_EMG("time used: %.6f(s)\r\n", time);
}
STATIC VOID OsPerfStart(VOID)
STATIC VOID OsPerfStart(VOID)//启动及更新CPU和计数器状态
{
UINT32 cpuid = ArchCurrCpuid();
@ -152,7 +155,7 @@ STATIC VOID OsPerfStart(VOID)
}
if (g_perfCb.pmuStatusPerCpu[cpuid] != PERF_PMU_STARTED) {
UINT32 ret = g_pmu->start();
UINT32 ret = g_pmu->start();//若计数器未启动则启动
if (ret != LOS_OK) {
PRINT_ERR("perf start on core:%u failed, ret = 0x%x\n", cpuid, ret);
return;
@ -164,7 +167,7 @@ STATIC VOID OsPerfStart(VOID)
}
}
STATIC VOID OsPerfStop(VOID)
STATIC VOID OsPerfStop(VOID)//停止性能计数器
{
UINT32 cpuid = ArchCurrCpuid();
@ -191,19 +194,21 @@ STATIC VOID OsPerfStop(VOID)
}
STATIC UINT32 OsPerfBackTrace(UINTPTR *callChain, UINT32 maxDepth, PerfRegs *regs)
//获取当前函数调用链的信息，并将结果存储在 callChain 数组中
{
UINT32 i;
UINT32 count = ArchBackTraceGet(regs->fp, callChain, maxDepth);
UINT32 count = ArchBackTraceGet(regs->fp, callChain, maxDepth);//获取当前状态的帧指针值
PRINT_DEBUG("backtrace depth = %u, fp = 0x%x\n", count, regs->fp);
for (i = 0; i < count; i++) {
PRINT_DEBUG("ip[%u]: 0x%x\n", i, callChain[i]);
PRINT_DEBUG("ip[%u]: 0x%x\n", i, callChain[i]);//打印调用链中每个函数的指令地址
}
return count;
return count;//返回用链的深度
}
STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *regs)
//收集性能计数器的数据，并将其存储在 data 结构体中
{
UINT32 size = 0;
UINT32 depth;
@ -211,12 +216,12 @@ STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *re
CHAR *p = (CHAR *)data;
if (sampleType & PERF_RECORD_CPU) {
*(UINT32 *)(p + size) = ArchCurrCpuid();
*(UINT32 *)(p + size) = ArchCurrCpuid();//函数获取当前CPU的ID，并存储在 data->cpuid 字段中
size += sizeof(data->cpuid);
}
if (sampleType & PERF_RECORD_TID) {
*(UINT32 *)(p + size) = LOS_CurTaskIDGet();
*(UINT32 *)(p + size) = LOS_CurTaskIDGet();// 函数获取当前任务的ID，并存储在 data->taskId 字段中
size += sizeof(data->taskId);
}
@ -231,7 +236,7 @@ STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *re
}
if (sampleType & PERF_RECORD_TIMESTAMP) {
*(UINT64 *)(p + size) = OsPerfGetCurrTime();
*(UINT64 *)(p + size) = OsPerfGetCurrTime();//获取当前时间戳，并存储在 data->time 字段中
size += sizeof(data->time);
}
@ -254,7 +259,7 @@ STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *re
* return TRUE if user haven't specified any taskId(which is supposed
* to instrument the whole system)
*/
STATIC BOOL OsPerfTaskFilter(UINT32 taskId)
STATIC BOOL OsPerfTaskFilter(UINT32 taskId)//过滤任务ID，判断一个给定的任务ID是否需要进行性能优化
{
UINT32 i;
@ -262,7 +267,7 @@ STATIC BOOL OsPerfTaskFilter(UINT32 taskId)
return TRUE;
}
for (i = 0; i < g_perfCb.taskIdsNr; i++) {
for (i = 0; i < g_perfCb.taskIdsNr; i++) { //储存允许过滤任务ID的列表
if (g_perfCb.taskIds[i] == taskId) {
return TRUE;
}
@ -270,7 +275,7 @@ STATIC BOOL OsPerfTaskFilter(UINT32 taskId)
return FALSE;
}
STATIC INLINE UINT32 OsPerfParamValid(VOID)
STATIC INLINE UINT32 OsPerfParamValid(VOID)//检查性能函数的有效性
{
UINT32 index;
UINT32 res = 0;
@ -287,7 +292,7 @@ STATIC INLINE UINT32 OsPerfParamValid(VOID)
return res;
}
STATIC UINT32 OsPerfHdrInit(UINT32 id)
STATIC UINT32 OsPerfHdrInit(UINT32 id)//初始化性能数据的头部信息
{
PerfDataHdr head = {
.magic = PERF_DATA_MAGIC_WORD,
@ -299,7 +304,7 @@ STATIC UINT32 OsPerfHdrInit(UINT32 id)
return OsPerfOutPutWrite((CHAR *)&head, head.len);
}
VOID OsPerfUpdateEventCount(Event *event, UINT32 value)
VOID OsPerfUpdateEventCount(Event *event, UINT32 value)//更新上传事件的技术
{
if (event == NULL) {
return;
@ -307,46 +312,46 @@ VOID OsPerfUpdateEventCount(Event *event, UINT32 value)
event->count[ArchCurrCpuid()] += (value & 0xFFFFFFFF); /* event->count is UINT64 */
}
VOID OsPerfHandleOverFlow(Event *event, PerfRegs *regs)
VOID OsPerfHandleOverFlow(Event *event, PerfRegs *regs)//处理性能计数器溢出的情况
{
PerfSampleData data;
UINT32 len;
(VOID)memset_s(&data, sizeof(PerfSampleData), 0, sizeof(PerfSampleData));
if ((g_perfCb.needSample) && OsPerfTaskFilter(LOS_CurTaskIDGet())) {
if ((g_perfCb.needSample) && OsPerfTaskFilter(LOS_CurTaskIDGet())) {//判断是否优化
len = OsPerfCollectData(event, &data, regs);
OsPerfOutPutWrite((CHAR *)&data, len);
}
}
UINT32 LOS_PerfInit(VOID *buf, UINT32 size)
UINT32 LOS_PerfInit(VOID *buf, UINT32 size)//初始化性能统计模块
{
UINT32 ret;
UINT32 intSave;
PERF_LOCK(intSave);
PERF_LOCK(intSave);//保存中断状态
if (g_perfCb.status != PERF_UNINIT) {
ret = LOS_ERRNO_PERF_STATUS_INVALID;
goto PERF_INIT_ERROR;
}
ret = OsPmuInit();
ret = OsPmuInit();//函数性能计数器初始化
if (ret != LOS_OK) {
goto PERF_INIT_ERROR;
}
ret = OsPerfOutPutInit(buf, size);
ret = OsPerfOutPutInit(buf, size);//性能输出缓冲区进行初始化
if (ret != LOS_OK) {
ret = LOS_ERRNO_PERF_BUF_ERROR;
goto PERF_INIT_ERROR;
}
g_perfCb.status = PERF_STOPED;
PERF_INIT_ERROR:
PERF_UNLOCK(intSave);
PERF_UNLOCK(intSave);//解锁中断处理
return ret;
}
UINT32 LOS_PerfConfig(PerfConfigAttr *attr)
UINT32 LOS_PerfConfig(PerfConfigAttr *attr)//配置性能统计模块的属性
{
UINT32 ret;
UINT32 intSave;
@ -355,20 +360,20 @@ UINT32 LOS_PerfConfig(PerfConfigAttr *attr)
return LOS_ERRNO_PERF_CONFIG_NULL;
}
PERF_LOCK(intSave);
PERF_LOCK(intSave);//保存中断状态
if (g_perfCb.status != PERF_STOPED) {
ret = LOS_ERRNO_PERF_STATUS_INVALID;
PRINT_ERR("perf config status error : 0x%x\n", g_perfCb.status);
goto PERF_CONFIG_ERROR;
}
g_pmu = NULL;
g_pmu = NULL;//将全局标量PMU计数器置零
g_perfCb.needSample = attr->needSample;
g_perfCb.taskFilterEnable = attr->taskFilterEnable;
g_perfCb.sampleType = attr->sampleType;
if (attr->taskFilterEnable) {
if (attr->taskFilterEnable) {//开启任务过滤功能
ret = memcpy_s(g_perfCb.taskIds, PERF_MAX_FILTER_TSKS * sizeof(UINT32), attr->taskIds,
g_perfCb.taskIdsNr * sizeof(UINT32));
if (ret != EOK) {
@ -377,29 +382,29 @@ UINT32 LOS_PerfConfig(PerfConfigAttr *attr)
}
g_perfCb.taskIdsNr = MIN(attr->taskIdsNr, PERF_MAX_FILTER_TSKS);
}
ret = OsPerfConfig(&attr->eventsCfg);
ret = OsPerfConfig(&attr->eventsCfg);//对事件配置进行处理
PERF_CONFIG_ERROR:
PERF_UNLOCK(intSave);
return ret;
}
VOID LOS_PerfStart(UINT32 sectionId)
VOID LOS_PerfStart(UINT32 sectionId)//启动性能统计模块
{
UINT32 intSave;
UINT32 ret;
PERF_LOCK(intSave);
if (g_perfCb.status != PERF_STOPED) {
if (g_perfCb.status != PERF_STOPED) {//判断统计模块是否打开
PRINT_ERR("perf start status error : 0x%x\n", g_perfCb.status);
goto PERF_START_ERROR;
}
if (!OsPerfParamValid()) {
if (!OsPerfParamValid()) {//检车行呢个统计模块的参数是否有效
PRINT_ERR("forgot call `LOS_Config(...)` before instrumenting?\n");
goto PERF_START_ERROR;
}
if (g_perfCb.needSample) {
if (g_perfCb.needSample) {//判断是否需要抽样
ret = OsPerfHdrInit(sectionId); /* section header init */
if (ret != LOS_OK) {
PRINT_ERR("perf hdr init error 0x%x\n", ret);
@ -407,7 +412,7 @@ VOID LOS_PerfStart(UINT32 sectionId)
}
}
SMP_CALL_PERF_FUNC(OsPerfStart); /* send to all cpu to start pmu */
SMP_CALL_PERF_FUNC(OsPerfStart); /* 所有CPU开始PMU计数器，启动性能统计模块i奥 */
g_perfCb.status = PERF_STARTED;
g_perfCb.startTime = OsPerfGetCurrTime();
PERF_START_ERROR:
@ -415,7 +420,7 @@ PERF_START_ERROR:
return;
}
VOID LOS_PerfStop(VOID)
VOID LOS_PerfStop(VOID)//停止性能统计模块的运行，进行一些清理操作
{
UINT32 intSave;
@ -427,12 +432,12 @@ VOID LOS_PerfStop(VOID)
SMP_CALL_PERF_FUNC(OsPerfStop); /* send to all cpu to stop pmu */
OsPerfOutPutFlush();
OsPerfOutPutFlush();//刷新输出操作
if (g_perfCb.needSample) {
OsPerfOutPutInfo();
}
//更新了两个全局变量的值，表示性能统计模块已经在状态上和时间上停止了
g_perfCb.status = PERF_STOPED;
g_perfCb.endTime = OsPerfGetCurrTime();
@ -442,21 +447,21 @@ PERF_STOP_ERROR:
return;
}
UINT32 LOS_PerfDataRead(CHAR *dest, UINT32 size)
UINT32 LOS_PerfDataRead(CHAR *dest, UINT32 size)//从性能统计门票快的输出缓冲区中读取数据到指定的内存
{
return OsPerfOutPutRead(dest, size);
}
VOID LOS_PerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func)
VOID LOS_PerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func)//注册型那个统计模块的通知hook函数
{
UINT32 intSave;
//保存中断状态，恢复中断状态
PERF_LOCK(intSave);
OsPerfNotifyHookReg(func);
PERF_UNLOCK(intSave);
}
VOID LOS_PerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)
VOID LOS_PerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)//刷新hook
{
UINT32 intSave;
@ -465,7 +470,7 @@ VOID LOS_PerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)
PERF_UNLOCK(intSave);
}
VOID OsPerfSetIrqRegs(UINTPTR pc, UINTPTR fp)
VOID OsPerfSetIrqRegs(UINTPTR pc, UINTPTR fp)//设置中断相关的寄存器，用于中断时的性能统计
{
LosTaskCB *runTask = (LosTaskCB *)ArchCurrTaskGet();
runTask->pc = pc;

22
src/kernel/extended/perf/perf_output.c
Unescape View File

@ -39,11 +39,14 @@ STATIC PERF_BUF_FLUSH_HOOK g_perfBufFlushHook = NULL;
STATIC PerfOutputCB g_perfOutputCb;
STATIC VOID OsPerfDefaultNotify(VOID)
//默认的性能缓冲区通知回调函数，在性能缓冲区的水位线达到一定值时打印一条信息
{
PRINT_INFO("perf buf waterline notify!\n");
}
UINT32 OsPerfOutPutInit(VOID *buf, UINT32 size)
//初始化性能输出模块。如果传入的缓冲区指针为空，则使用LOS_MemAlloc函数动态分配内存。
//然后初始化环形缓冲区，设置水位线，并注册默认的性能缓冲区通知回调函数
{
UINT32 ret;
BOOL releaseFlag = FALSE;
@ -69,21 +72,22 @@ RELEASE:
return ret;
}
VOID OsPerfOutPutFlush(VOID)
VOID OsPerfOutPutFlush(VOID)//刷新性能输出缓冲区
{
if (g_perfBufFlushHook != NULL) {
g_perfBufFlushHook(g_perfOutputCb.ringbuf.fifo, g_perfOutputCb.ringbuf.size);
}
}
UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size)
UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size)//从性能输出缓冲区中读取数据
{
OsPerfOutPutFlush();
return LOS_RingbufRead(&g_perfOutputCb.ringbuf, dest, size);
}
STATIC BOOL OsPerfOutPutBegin(UINT32 size)
STATIC BOOL OsPerfOutPutBegin(UINT32 size)//开始写入性能输出缓冲区
{
//检查是否有足够空间
if (g_perfOutputCb.ringbuf.remain < size) {
PRINT_INFO("perf buf has no enough space for 0x%x\n", size);
return FALSE;
@ -91,9 +95,9 @@ STATIC BOOL OsPerfOutPutBegin(UINT32 size)
return TRUE;
}
STATIC VOID OsPerfOutPutEnd(VOID)
STATIC VOID OsPerfOutPutEnd(VOID)//结束性能输出
{
OsPerfOutPutFlush();
OsPerfOutPutFlush();//刷新缓冲区
if (LOS_RingbufUsedSize(&g_perfOutputCb.ringbuf) >= g_perfOutputCb.waterMark) {
if (g_perfBufNotifyHook != NULL) {
g_perfBufNotifyHook();
@ -101,7 +105,7 @@ STATIC VOID OsPerfOutPutEnd(VOID)
}
}
UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size)
UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size)//将数据写入性能输入缓冲区
{
if (!OsPerfOutPutBegin(size)) {
return LOS_NOK;
@ -113,17 +117,17 @@ UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size)
return LOS_OK;
}
VOID OsPerfOutPutInfo(VOID)
VOID OsPerfOutPutInfo(VOID)//打印性能输出缓冲区的信息，包括地址和长度
{
PRINT_EMG("dump section data, addr: %p length: %#x \r\n", g_perfOutputCb.ringbuf.fifo, g_perfOutputCb.ringbuf.size);
}
VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func)
VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func)//注册性能缓冲区通知
{
g_perfBufNotifyHook = func;
}
VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)
VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)//注册性能缓冲区刷新的函数
{
g_perfBufFlushHook = func;
}

14
src/kernel/extended/perf/perf_output_pri.h
Unescape View File

@ -43,13 +43,13 @@ typedef struct {
UINT32 waterMark; /* notify water mark */
} PerfOutputCB;
extern UINT32 OsPerfOutPutInit(VOID *buf, UINT32 size);
extern UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size);
extern UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size);
extern VOID OsPerfOutPutInfo(VOID);
extern VOID OsPerfOutPutFlush(VOID);
extern VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func);
extern VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func);
extern UINT32 OsPerfOutPutInit(VOID *buf, UINT32 size);//初始化性能输出模块
extern UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size);//从性能输出缓冲区中读取数据，将数据拷贝到指定的目标缓冲区中
extern UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size);//将数据写入性能输出缓冲区
extern VOID OsPerfOutPutInfo(VOID);//输出性能统计信息
extern VOID OsPerfOutPutFlush(VOID);//刷新性能输出缓冲区
extern VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func);//注册性能输出缓冲区通知
extern VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func);//注册性能输出缓冲区刷新
#ifdef __cplusplus
#if __cplusplus

13
src/kernel/extended/perf/perf_pmu.c
Unescape View File

@ -36,11 +36,11 @@ extern "C" {
STATIC Pmu *g_pmuMgr[PERF_EVENT_TYPE_MAX] = {NULL};
UINT32 OsPerfPmuRegister(Pmu *pmu)
UINT32 OsPerfPmuRegister(Pmu *pmu)//注册性能计数器
{
UINT32 type;
if ((pmu == NULL) || (pmu->type >= PERF_EVENT_TYPE_MAX)) {
if ((pmu == NULL) || (pmu->type >= PERF_EVENT_TYPE_MAX)) {//如果传入PMU为空指针或者type超出了有效范围
return LOS_NOK;
}
@ -52,19 +52,20 @@ UINT32 OsPerfPmuRegister(Pmu *pmu)
return LOS_NOK;
}
Pmu *OsPerfPmuGet(UINT32 type)
Pmu *OsPerfPmuGet(UINT32 type)//获取指定类型的性能计数器
{
if (type >= PERF_EVENT_TYPE_MAX) {
return NULL;
}
if (type == PERF_EVENT_TYPE_RAW) { /* process hardware raw events with hard pmu */
type = PERF_EVENT_TYPE_HW;
if (type == PERF_EVENT_TYPE_RAW) { //如果是原始事件类型
/* process hardware raw events with hard pmu */
type = PERF_EVENT_TYPE_HW;//则将其转化为硬件事件类型
}
return g_pmuMgr[type];
}
VOID OsPerfPmuRm(UINT32 type)
VOID OsPerfPmuRm(UINT32 type)//删除指定类型的性能计数器
{
if (type >= PERF_EVENT_TYPE_MAX) {
return;

38
src/kernel/extended/perf/perf_pmu_pri.h
Unescape View File

@ -53,7 +53,7 @@ typedef struct {
VOID (*setPeriod)(Event *event);
UINTPTR (*readCnt)(Event *event);
UINT32 (*mapEvent)(UINT32 eventType, BOOL reverse);
} HwPmu;
} HwPmu;//硬件性能计数器结构体，包括硬件计数器、计数器是否能被分频、分频系数、启用、禁用、开始、停止、清除、设置周期、读取计数器值和事件映射等函数指针
typedef struct {
Pmu pmu;
@ -69,35 +69,35 @@ typedef struct {
};
#endif
};
} SwPmu;
} SwPmu;//软件性能计数器结构体，包括软件计数器、是否启用标志位、定时器配置时间
#define GET_HW_PMU(item) LOS_DL_LIST_ENTRY(item, HwPmu, pmu)
#define TIMER_PERIOD_LOWER_BOUND_US 100
#define TIMER_PERIOD_LOWER_BOUND_US 100//定时器最小周期
#define CCNT_FULL 0xFFFFFFFF
#define CCNT_PERIOD_LOWER_BOUND 0x00000000
#define CCNT_PERIOD_UPPER_BOUND 0xFFFFFF00
#define PERIOD_CALC(p) (CCNT_FULL - (p))
#define CCNT_FULL 0xFFFFFFFF//计数器最大值
#define CCNT_PERIOD_LOWER_BOUND 0x00000000//最小周期
#define CCNT_PERIOD_UPPER_BOUND 0xFFFFFF00//最大周期
#define PERIOD_CALC(p) (CCNT_FULL - (p))//计算给定周期对应的计数器值
#define VALID_PERIOD(p) ((PERIOD_CALC(p) > CCNT_PERIOD_LOWER_BOUND) \
&& (PERIOD_CALC(p) < CCNT_PERIOD_UPPER_BOUND))
&& (PERIOD_CALC(p) < CCNT_PERIOD_UPPER_BOUND))//判断给定周期是否合法
#define PERF_HW_INVAILD_EVENT_TYPE 0xFFFFFFFF
#define PERF_HW_INVAILD_EVENT_TYPE 0xFFFFFFFF//无效的事件类型
#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
extern UINT32 OsPerfPmuRegister(Pmu *pmu);
extern VOID OsPerfPmuRm(UINT32 type);
extern Pmu *OsPerfPmuGet(UINT32 type);
extern UINT32 OsPerfPmuRegister(Pmu *pmu);//注册硬件性能计数器
extern VOID OsPerfPmuRm(UINT32 type);//删除硬件性能计数器
extern Pmu *OsPerfPmuGet(UINT32 type);//获取指定类型的硬件性能计数器
extern UINT32 OsHwPmuInit(VOID);
extern UINT32 OsSwPmuInit(VOID);
extern UINT32 OsTimedPmuInit(VOID);
extern UINT32 OsHwPmuInit(VOID);//初始化硬件性能计数器
extern UINT32 OsSwPmuInit(VOID);//初始化软件性能计数器
extern UINT32 OsTimedPmuInit(VOID);//初始化定时器性能计数器
extern UINT32 OsGetPmuCounter0(VOID);
extern UINT32 OsGetPmuMaxCounter(VOID);
extern UINT32 OsGetPmuCycleCounter(VOID);
extern UINT32 OsPerfHwInit(HwPmu *hwPmu);
extern UINT32 OsGetPmuCounter0(VOID);//获取0核计数器值
extern UINT32 OsGetPmuMaxCounter(VOID);//获取最大计数器数
extern UINT32 OsGetPmuCycleCounter(VOID);//获取周期性计数器值
extern UINT32 OsPerfHwInit(HwPmu *hwPmu);//初始化硬件性能计数器
#ifdef __cplusplus
#if __cplusplus

50
src/kernel/extended/perf/pmu/perf_hw_pmu.c
Unescape View File

@ -34,7 +34,7 @@ extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
STATIC Pmu *g_perfHw = NULL;
STATIC Pmu *g_perfHw = NULL;//指向性能计数器相关的数据结构或对象
STATIC CHAR *g_eventName[PERF_COUNT_HW_MAX] = {
[PERF_COUNT_HW_CPU_CYCLES] = "cycles",
@ -53,39 +53,41 @@ STATIC CHAR *g_eventName[PERF_COUNT_HW_MAX] = {
* 2.Find available counter for each event.
* 3.Decide whether this hardware pmu need prescaler (once every 64 cycle counts).
*/
STATIC UINT32 OsPerfHwConfig(VOID)
STATIC UINT32 OsPerfHwConfig(VOID)//性能计数器的配置函数，用于初始化和配置硬件性能计数器
{
UINT32 i;
HwPmu *armPmu = GET_HW_PMU(g_perfHw);
UINT32 maxCounter = OsGetPmuMaxCounter();
UINT32 counter = OsGetPmuCounter0();
UINT32 cycleCounter = OsGetPmuCycleCounter();
UINT32 maxCounter = OsGetPmuMaxCounter();//获得最大计数器数量
UINT32 counter = OsGetPmuCounter0();//获取0核计数器的值
UINT32 cycleCounter = OsGetPmuCycleCounter();//周期计数器的值
UINT32 cycleCode = armPmu->mapEvent(PERF_COUNT_HW_CPU_CYCLES, PERF_EVENT_TO_CODE);
if (cycleCode == PERF_HW_INVAILD_EVENT_TYPE) {
return LOS_NOK;
}
//获取性能事件的列表的和数量并进行遍历
PerfEvent *events = &g_perfHw->events;
UINT32 eventNum = events->nr;
for (i = 0; i < eventNum; i++) {
Event *event = &(events->per[i]);
if (!VALID_PERIOD(event->period)) {
if (!VALID_PERIOD(event->period)) {//检查事件周期是否合法
PRINT_ERR("Config period: 0x%x invalid, should be in (%#x, %#x)\n", event->period,
PERIOD_CALC(CCNT_PERIOD_UPPER_BOUND), PERIOD_CALC(CCNT_PERIOD_LOWER_BOUND));
return LOS_NOK;
}
if (g_perfHw->type == PERF_EVENT_TYPE_HW) { /* do map */
//映射编码
UINT32 eventId = armPmu->mapEvent(event->eventId, PERF_EVENT_TO_CODE);
if (eventId == PERF_HW_INVAILD_EVENT_TYPE) {
return LOS_NOK;
}
event->eventId = eventId;
}
//函数根据事件编码是否与周期计数器的事件编码相同，来确定该事件使用的计数器。
//如果相同，则使用周期计数器；否则，使用普通计数器，并递增计数器的值。
if (event->eventId == cycleCode) {
event->counter = cycleCounter;
} else {
@ -93,11 +95,11 @@ STATIC UINT32 OsPerfHwConfig(VOID)
counter++;
}
if (counter >= maxCounter) {
if (counter >= maxCounter) {//检查计数器是否超过了最大计数器数量
PRINT_ERR("max events: %u excluding cycle event\n", maxCounter - 1);
return LOS_NOK;
}
//打印结果，设置根据平台支持的分频
PRINT_DEBUG("Perf Config %u eventId = 0x%x, counter = 0x%x, period = 0x%x\n", i, event->eventId, event->counter,
event->period);
}
@ -106,21 +108,21 @@ STATIC UINT32 OsPerfHwConfig(VOID)
return LOS_OK;
}
STATIC UINT32 OsPerfHwStart(VOID)
STATIC UINT32 OsPerfHwStart(VOID)//用于启动硬件性能计数器
{
UINT32 i;
UINT32 cpuid = ArchCurrCpuid();
HwPmu *armPmu = GET_HW_PMU(g_perfHw);
HwPmu *armPmu = GET_HW_PMU(g_perfHw);//获取硬件性能计数器的指针
PerfEvent *events = &g_perfHw->events;
UINT32 eventNum = events->nr;
armPmu->clear();
armPmu->clear();//清零计数器
for (i = 0; i < eventNum; i++) {
Event *event = &(events->per[i]);
armPmu->setPeriod(event);
armPmu->enable(event);
armPmu->setPeriod(event);//设置事件的计数周期
armPmu->enable(event);//启用事件的计数器
event->count[cpuid] = 0;
}
@ -128,7 +130,7 @@ STATIC UINT32 OsPerfHwStart(VOID)
return LOS_OK;
}
STATIC UINT32 OsPerfHwStop(VOID)
STATIC UINT32 OsPerfHwStop(VOID)//停止硬件性能计数器
{
UINT32 i;
UINT32 cpuid = ArchCurrCpuid();
@ -148,7 +150,9 @@ STATIC UINT32 OsPerfHwStop(VOID)
/* multiplier of cycle counter */
UINT32 eventId = armPmu->mapEvent(event->eventId, PERF_CODE_TO_EVENT);
if ((eventId == PERF_COUNT_HW_CPU_CYCLES) && (armPmu->cntDivided != 0)) {
//如果该事件的事件ID与周期计数器事件ID相同，并且硬件性能计数器的分频设置armPmu->cntDivided不为0
PRINT_DEBUG("perf stop is cycle\n");
//此处将该事件的计数值左移6位，相当于乘以64
event->count[cpuid] = event->count[cpuid] << 6; /* CCNT counts every 64th cpu cycle */
}
PRINT_DEBUG("perf stop eventCount[0x%x] : [%s] = %llu\n", event->eventId, g_eventName[eventId],
@ -157,11 +161,11 @@ STATIC UINT32 OsPerfHwStop(VOID)
return LOS_OK;
}
STATIC CHAR *OsPerfGetEventName(Event *event)
STATIC CHAR *OsPerfGetEventName(Event *event)//获取事件名称
{
UINT32 eventId;
HwPmu *armPmu = GET_HW_PMU(g_perfHw);
eventId = armPmu->mapEvent(event->eventId, PERF_CODE_TO_EVENT);
HwPmu *armPmu = GET_HW_PMU(g_perfHw);//获取PMU上的事件信息
eventId = armPmu->mapEvent(event->eventId, PERF_CODE_TO_EVENT);//将事件ID映射位对应计数器事件ID
if (eventId < PERF_COUNT_HW_MAX) {
return g_eventName[eventId];
} else {
@ -169,21 +173,21 @@ STATIC CHAR *OsPerfGetEventName(Event *event)
}
}
UINT32 OsPerfHwInit(HwPmu *hwPmu)
UINT32 OsPerfHwInit(HwPmu *hwPmu)//初始化性能计数器
{
UINT32 ret;
if (hwPmu == NULL) {
return LOS_NOK;
}
//设置性能计数器的类型，配置函数，启动函数，停止函数，获取事件名称函数
hwPmu->pmu.type = PERF_EVENT_TYPE_HW;
hwPmu->pmu.config = OsPerfHwConfig;
hwPmu->pmu.start = OsPerfHwStart;
hwPmu->pmu.stop = OsPerfHwStop;
hwPmu->pmu.getName = OsPerfGetEventName;
//将硬件性能计数器的事件数据结构清零
(VOID)memset_s(&hwPmu->pmu.events, sizeof(PerfEvent), 0, sizeof(PerfEvent));
ret = OsPerfPmuRegister(&hwPmu->pmu);
ret = OsPerfPmuRegister(&hwPmu->pmu);//注册硬件性能计数器，将其存储在全局变量中
g_perfHw = OsPerfPmuGet(PERF_EVENT_TYPE_HW);
return ret;

20
src/kernel/extended/perf/pmu/perf_sw_pmu.c
Unescape View File

@ -51,7 +51,7 @@ STATIC CHAR* g_eventName[PERF_COUNT_SW_MAX] = {
[PERF_COUNT_SW_MUX_PEND] = "mux pend",
};
VOID OsPerfHook(UINT32 eventType)
VOID OsPerfHook(UINT32 eventType)//软件性能计数器的事件处理函数
{
if (!g_perfSw.enable) {
return;
@ -69,7 +69,7 @@ VOID OsPerfHook(UINT32 eventType)
if (event->counter == eventType) {
OsPerfUpdateEventCount(event, 1);
if (event->count[ArchCurrCpuid()] % event->period == 0) {
OsPerfFetchCallerRegs(&regs);
OsPerfFetchCallerRegs(&regs);//获取寄存器信息
OsPerfHandleOverFlow(event, &regs);
}
return;
@ -77,7 +77,7 @@ VOID OsPerfHook(UINT32 eventType)
}
}
STATIC UINT32 OsPerfSwConfig(VOID)
STATIC UINT32 OsPerfSwConfig(VOID)//对软件性能计数器进行配置
{
UINT32 i;
PerfEvent *events = &g_perfSw.pmu.events;
@ -94,29 +94,29 @@ STATIC UINT32 OsPerfSwConfig(VOID)
return LOS_OK;
}
STATIC UINT32 OsPerfSwStart(VOID)
STATIC UINT32 OsPerfSwStart(VOID)//启动软件性能计数器
{
UINT32 i;
UINT32 cpuid = ArchCurrCpuid();
PerfEvent *events = &g_perfSw.pmu.events;
UINT32 eventNum = events->nr;
for (i = 0; i < eventNum; i++) {
for (i = 0; i < eventNum; i++) {//遍历所有事件
Event *event = &(events->per[i]);
event->count[cpuid] = 0;
event->count[cpuid] = 0;//清零当前事件在CPU中的计数器
}
g_perfSw.enable = TRUE;
g_perfSw.enable = TRUE;//启动计数器
return LOS_OK;
}
STATIC UINT32 OsPerfSwStop(VOID)
STATIC UINT32 OsPerfSwStop(VOID)//关闭软件性能计数器
{
g_perfSw.enable = FALSE;
return LOS_OK;
}
STATIC CHAR *OsPerfGetEventName(Event *event)
STATIC CHAR *OsPerfGetEventName(Event *event)//获取事件的名称
{
UINT32 eventId = event->eventId;
if (eventId < PERF_COUNT_SW_MAX) {
@ -125,7 +125,7 @@ STATIC CHAR *OsPerfGetEventName(Event *event)
return "unknown";
}
UINT32 OsSwPmuInit(VOID)
UINT32 OsSwPmuInit(VOID)//对PMU计数器进行初始化
{
g_perfSw.pmu = (Pmu) {
.type = PERF_EVENT_TYPE_SW,

40
src/kernel/extended/perf/pmu/perf_timed_pmu.c
Unescape View File

@ -39,12 +39,12 @@ extern "C" {
STATIC SwPmu g_perfTimed;
STATIC BOOL OsPerfTimedPeriodValid(UINT32 period)
STATIC BOOL OsPerfTimedPeriodValid(UINT32 period)//验证定时器中的时间周期是否合法
{
return period >= TIMER_PERIOD_LOWER_BOUND_US;
}
STATIC UINT32 OsPerfTimedStart(VOID)
STATIC UINT32 OsPerfTimedStart(VOID)//启动定时器事件
{
UINT32 i;
UINT32 cpuid = ArchCurrCpuid();
@ -74,7 +74,7 @@ STATIC UINT32 OsPerfTimedStart(VOID)
return LOS_OK;
}
STATIC UINT32 OsPerfTimedConfig(VOID)
STATIC UINT32 OsPerfTimedConfig(VOID)//配置定时器，检验是否合法
{
UINT32 i;
PerfEvent *events = &g_perfTimed.pmu.events;
@ -101,7 +101,7 @@ STATIC UINT32 OsPerfTimedConfig(VOID)
return LOS_NOK;
}
STATIC UINT32 OsPerfTimedStop(VOID)
STATIC UINT32 OsPerfTimedStop(VOID)//关闭定时器设置
{
UINT32 ret;
if (ArchCurrCpuid() != 0) { /* only need stop on one core */
@ -116,7 +116,7 @@ STATIC UINT32 OsPerfTimedStop(VOID)
return LOS_OK;
}
STATIC VOID OsPerfTimedHandle(VOID)
STATIC VOID OsPerfTimedHandle(VOID)//处理定时器事件
{
UINT32 index;
PerfRegs regs;
@ -125,7 +125,7 @@ STATIC VOID OsPerfTimedHandle(VOID)
UINT32 eventNum = events->nr;
(VOID)memset_s(&regs, sizeof(PerfRegs), 0, sizeof(PerfRegs));
OsPerfFetchIrqRegs(&regs);
OsPerfFetchIrqRegs(&regs);//获取当前寄存器状态
for (index = 0; index < eventNum; index++) {
Event *event = &(events->per[index]);
@ -134,48 +134,50 @@ STATIC VOID OsPerfTimedHandle(VOID)
}
}
STATIC enum hrtimer_restart OsPerfHrtimer(struct hrtimer *hrtimer)
STATIC enum hrtimer_restart OsPerfHrtimer(struct hrtimer *hrtimer)//高精度定时器(hrtimer)的回调函数
{
SMP_CALL_PERF_FUNC(OsPerfTimedHandle); /* send to all cpu to collect data */
//将定时器事件的处理发送给所有CPU进行数据收集
return HRTIMER_RESTART;
}
STATIC CHAR *OsPerfGetEventName(Event *event)
STATIC CHAR *OsPerfGetEventName(Event *event)//获取事件名称
{
if (event->eventId == PERF_COUNT_CPU_CLOCK) {
if (event->eventId == PERF_COUNT_CPU_CLOCK) {//读取事件ID是否与计数器中的事件记录相同
return "timed";
} else {
return "unknown";
}
}
UINT32 OsTimedPmuInit(VOID)
UINT32 OsTimedPmuInit(VOID)//初始化定时器
{
UINT32 ret;
g_perfTimed.time = (union ktime) {
g_perfTimed.time = (union ktime) {//保存定时器信息
.tv.sec = 0,
.tv.usec = HRTIMER_DEFAULT_PERIOD_US,
};
hrtimer_init(&g_perfTimed.hrtimer, 1, HRTIMER_MODE_REL);
hrtimer_init(&g_perfTimed.hrtimer, 1, HRTIMER_MODE_REL);//第一个参数代表定时器对象，第二个参数为时间源类型，代表的是相对时间，最后一个参数代表定时器模式，这里使用的是相对时间模式
ret = hrtimer_create(&g_perfTimed.hrtimer, g_perfTimed.time, OsPerfHrtimer);
ret = hrtimer_create(&g_perfTimed.hrtimer, g_perfTimed.time, OsPerfHrtimer);//创建定时器
if (ret != LOS_OK) {
return ret;
}
g_perfTimed.pmu = (Pmu) {
.type = PERF_EVENT_TYPE_TIMED,
.config = OsPerfTimedConfig,
.start = OsPerfTimedStart,
.stop = OsPerfTimedStop,
.getName = OsPerfGetEventName,
.type = PERF_EVENT_TYPE_TIMED,//此性能计数器是定时器类型
.config = OsPerfTimedConfig,//性能计数器的事件配置
.start = OsPerfTimedStart,//启动
.stop = OsPerfTimedStop,//停止
.getName = OsPerfGetEventName,//获取事件名称
};
(VOID)memset_s(&g_perfTimed.pmu.events, sizeof(PerfEvent), 0, sizeof(PerfEvent));
//执行完之后清零事件结构体，并在下面进行状态码的注册读取
ret = OsPerfPmuRegister(&g_perfTimed.pmu);
return ret;
return ret;//返回值为初始化状态码
}
#ifdef __cplusplus

BIN
src/kernel/extended/软件工程代码阅读（初稿）-何佳聪-.docx
View File

Binary file not shown.

55
src/kernel/include/arch_generic/atomic.h
Unescape View File

@ -31,6 +31,7 @@
* @ingroup kernel
*/
//在LiteOS操作系统中，atomic.h头文件通常用于提供原子操作的支持。原子操作是不可中断的操作，它可以确保在多线程环境中对共享资源进行安全的访问和修改。
#ifndef _ARCH_GENERIC_ATOMIC_H
#define _ARCH_GENERIC_ATOMIC_H
@ -44,17 +45,26 @@ extern "C" {
#endif /* __cplusplus */
#ifndef LOSCFG_KERNEL_SMP
/*ArchAtomicRead 函数用于原子读取一个整数变量的值。
它将一个指向原子变量的指针 v 强制转换为 volatile INT32 类型的指针，
并返回该指针所指向的值。*/
STATIC INLINE INT32 ArchAtomicRead(const Atomic *v)
{
return *(volatile INT32 *)v;
}
/*ArchAtomicSet 函数用于原子设置一个整数变量的值。
它将一个指向原子变量的指针 v 强制转换为 volatile INT32 类型的指针，
并将 setVal 的值赋给该指针所指向的变量。*/
STATIC INLINE VOID ArchAtomicSet(Atomic *v, INT32 setVal)
{
*(volatile INT32 *)v = setVal;
}
/*ArchAtomicAdd 函数用于原子增加一个整数变量的值。
它先保存当前中断状态，然后在关闭中断的情况下，将 addVal 加到指针 v 所指向的变量上，
并返回增加后的值。
最后，恢复之前保存的中断状态。*/
STATIC INLINE INT32 ArchAtomicAdd(Atomic *v, INT32 addVal)
{
UINT32 intSave;
@ -66,6 +76,9 @@ STATIC INLINE INT32 ArchAtomicAdd(Atomic *v, INT32 addVal)
return *v;
}
/*ArchAtomicSub 函数用于原子减少一个整数变量的值。
它的实现与 ArchAtomicAdd 类似，
只是将 subVal 减去指针 v 所指向的变量。*/
STATIC INLINE INT32 ArchAtomicSub(Atomic *v, INT32 subVal)
{
UINT32 intSave;
@ -77,6 +90,10 @@ STATIC INLINE INT32 ArchAtomicSub(Atomic *v, INT32 subVal)
return *v;
}
/*ArchAtomicInc 函数用于原子增加一个整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 addr 指向的变量加 1，
最后恢复之前保存的中断状态。*/
STATIC INLINE VOID ArchAtomicInc(Atomic *addr)
{
UINT32 intSave;
@ -86,6 +103,7 @@ STATIC INLINE VOID ArchAtomicInc(Atomic *addr)
LOS_IntRestore(intSave);
}
//ArchAtomicIncRet 函数与 ArchAtomicInc 类似，但它还返回增加后的变量值。
STATIC INLINE INT32 ArchAtomicIncRet(Atomic *addr)
{
UINT32 intSave;
@ -96,6 +114,7 @@ STATIC INLINE INT32 ArchAtomicIncRet(Atomic *addr)
return *addr;
}
//ArchAtomicDec 函数用于原子减少一个整数变量的值。它的实现类似于 ArchAtomicInc，只是将指针 addr 指向的变量减 1。
STATIC INLINE VOID ArchAtomicDec(Atomic *addr)
{
UINT32 intSave;
@ -105,6 +124,7 @@ STATIC INLINE VOID ArchAtomicDec(Atomic *addr)
LOS_IntRestore(intSave);
}
//ArchAtomicDecRet 函数与 ArchAtomicDec 类似，但它还返回减少后的变量值。
STATIC INLINE INT32 ArchAtomicDecRet(Atomic *addr)
{
UINT32 intSave;
@ -115,6 +135,10 @@ STATIC INLINE INT32 ArchAtomicDecRet(Atomic *addr)
return *addr;
}
/*ArchAtomic64Read 函数用于原子读取一个 64 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
读取指针 v 指向的 64 位整数变量的值，
最后恢复之前保存的中断状态，并返回读取的值。*/
STATIC INLINE INT64 ArchAtomic64Read(const Atomic64 *v)
{
UINT32 intSave;
@ -127,6 +151,10 @@ STATIC INLINE INT64 ArchAtomic64Read(const Atomic64 *v)
return val;
}
/*ArchAtomic64Set 函数用于原子设置一个 64 位整数变量的值为 setVal。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量设置为 setVal，
最后恢复之前保存的中断状态。*/
STATIC INLINE VOID ArchAtomic64Set(Atomic64 *v, INT64 setVal)
{
UINT32 intSave;
@ -136,6 +164,10 @@ STATIC INLINE VOID ArchAtomic64Set(Atomic64 *v, INT64 setVal)
LOS_IntRestore(intSave);
}
/*ArchAtomic64Add 函数用于原子增加一个 64 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量增加 addVal，然后将增加后的值赋给变量 val，
最后恢复之前保存的中断状态，并返回 val。*/
STATIC INLINE INT64 ArchAtomic64Add(Atomic64 *v, INT64 addVal)
{
UINT32 intSave;
@ -149,6 +181,9 @@ STATIC INLINE INT64 ArchAtomic64Add(Atomic64 *v, INT64 addVal)
return val;
}
/*ArchAtomic64Sub 函数用于原子减少一个 64 位整数变量的值。
它的实现类似于 ArchAtomic64Add，
只是将指针 v 指向的变量减去 subVal。*/
STATIC INLINE INT64 ArchAtomic64Sub(Atomic64 *v, INT64 subVal)
{
UINT32 intSave;
@ -162,6 +197,8 @@ STATIC INLINE INT64 ArchAtomic64Sub(Atomic64 *v, INT64 subVal)
return val;
}
/*ArchAtomic64Inc 函数用于原子增加一个 64 位整数变量的值。
它的实现类似于 ArchAtomic64Add，只是将增加的值固定为 1。*/
STATIC INLINE VOID ArchAtomic64Inc(Atomic64 *v)
{
UINT32 intSave;
@ -171,6 +208,7 @@ STATIC INLINE VOID ArchAtomic64Inc(Atomic64 *v)
LOS_IntRestore(intSave);
}
//ArchAtomic64IncRet 函数与 ArchAtomic64Inc 类似，但它还返回增加后的变量值。
STATIC INLINE INT64 ArchAtomic64IncRet(Atomic64 *v)
{
UINT32 intSave;
@ -184,6 +222,9 @@ STATIC INLINE INT64 ArchAtomic64IncRet(Atomic64 *v)
return val;
}
/*ArchAtomic64Dec 函数用于原子减少一个 64 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，将指针 v 指向的变量减去 1，
最后恢复之前保存的中断状态。*/
STATIC INLINE VOID ArchAtomic64Dec(Atomic64 *v)
{
UINT32 intSave;
@ -193,6 +234,7 @@ STATIC INLINE VOID ArchAtomic64Dec(Atomic64 *v)
LOS_IntRestore(intSave);
}
//ArchAtomic64DecRet 函数与 ArchAtomic64Dec 类似，但它还返回减少后的变量值。
STATIC INLINE INT64 ArchAtomic64DecRet(Atomic64 *v)
{
UINT32 intSave;
@ -206,6 +248,10 @@ STATIC INLINE INT64 ArchAtomic64DecRet(Atomic64 *v)
return val;
}
/*ArchAtomicXchg32bits 函数用于原子交换一个 32 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量的值赋给 prevVal，再将变量 v 的值设置为 val，
最后恢复之前保存的中断状态，并返回原先的值 prevVal。*/
STATIC INLINE INT32 ArchAtomicXchg32bits(Atomic *v, INT32 val)
{
UINT32 intSave;
@ -219,6 +265,7 @@ STATIC INLINE INT32 ArchAtomicXchg32bits(Atomic *v, INT32 val)
return prevVal;
}
//ArchAtomicXchg64bits 函数类似于 ArchAtomicXchg32bits，但它用于原子交换一个 64 位整数变量的值。
STATIC INLINE INT64 ArchAtomicXchg64bits(Atomic64 *v, INT64 val)
{
UINT32 intSave;
@ -232,6 +279,11 @@ STATIC INLINE INT64 ArchAtomicXchg64bits(Atomic64 *v, INT64 val)
return prevVal;
}
/*ArchAtomicCmpXchg32bits 函数用于原子比较和交换一个 32 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量的值赋给 prevVal，接着判断 prevVal 是否等于 oldVal，
如果相等，则将变量 v 的值设置为 val，最后恢复之前保存的中断状态，
并返回是否执行了交换操作的布尔值。*/
STATIC INLINE BOOL ArchAtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal)
{
UINT32 intSave;
@ -247,6 +299,7 @@ STATIC INLINE BOOL ArchAtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal)
return (prevVal != oldVal);
}
//ArchAtomicCmpXchg64bits 函数类似于 ArchAtomicCmpXchg32bits，但它用于原子比较和交换一个 64 位整数变量的值。
STATIC INLINE BOOL ArchAtomicCmpXchg64bits(Atomic64 *v, INT64 val, INT64 oldVal)
{
UINT32 intSave;

132
src/kernel/include/console.h
Unescape View File

@ -25,18 +25,18 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */
//在LiteOS操作系统中，console头文件通常用于定义与控制台交互相关的函数和数据结构。
#ifndef _CONSOLE_H
#define _CONSOLE_H
#include "los_config.h"
#ifdef LOSCFG_FS_VFS
#include "termios.h"
#ifdef LOSCFG_NET_TELNET
#include "telnet_dev.h"
#endif
#include "virtual_serial.h"
#include "los_ringbuf.h"
//代码中，首先使用了条件编译防护，以确保头文件内容只被包含一次。接着定义了控制台输入输出缓冲区的大小，并声明了控制台初始化、打印和读取等函数。
#include "los_config.h"//引用了系统配置文件，用于获取操作系统的一些设置和属性。
#ifdef LOSCFG_FS_VFS//使用条件编译指令判断是否定义了宏LOSCFG_FS_VFS，如果已经定义，则编译下面的代码块，否则跳过。
#include "termios.h"//包含了 POSIX 终端控制定义的头文件，用于对终端进行控制。
#ifdef LOSCFG_NET_TELNET//使用条件编译指令判断是否定义了宏,如果已经定义，则编译下面的代码块，否则跳过。
#include "telnet_dev.h"//包含了 Telnet 设备驱动的头文件，用于实现 Telnet 连接。
#endif//结束条件编译指令。
#include "virtual_serial.h"//包含了虚拟串口的头文件，用于实现虚拟串口的功能。
#include "los_ringbuf.h"//包含了环形缓冲区的头文件，用于实现缓冲区的读写操作。
#endif
#ifdef __cplusplus
@ -57,76 +57,76 @@ extern "C" {
#define CONSOLE "/dev/console"
#define CONSOLE_NAMELEN 16
#define CONSOLE_CMD_RD_BLOCK_SERIAL 0x104
#define CONSOLE_CMD_RD_BLOCK_TELNET 101
#define CONSOLE_RD_BLOCK 1
#define CONSOLE_RD_NONBLOCK 0
#define CONSOLE_SHELL_KEY_EVENT 0x112
#define CONSOLE_SHELL_EXITED 0x400
#define CONSOLE_CONTROL_RIGHTS_CAPTURE 201
#define CONSOLE_CONTROL_RIGHTS_RELEASE 202
#define CONSOLE_CONTROL_CAPTURE_LINE 203
#define CONSOLE_CONTROL_CAPTURE_CHAR 204
#define CONSOLE_FIFO_SIZE 1024
#define CONSOLE_NUM 2
//这段代码定义了一些宏和常量，它们的含义如下：
#define CONSOLE_CMD_RD_BLOCK_SERIAL 0x104//表示从串口读取数据的阻塞命令，其值为0x104。
#define CONSOLE_CMD_RD_BLOCK_TELNET 101//表示从Telnet连接读取数据的阻塞命令，其值为101。
#define CONSOLE_RD_BLOCK 1//表示阻塞模式，其值为1。
#define CONSOLE_RD_NONBLOCK 0//表示非阻塞模式，其值为0。
#define CONSOLE_SHELL_KEY_EVENT 0x112//表示shell键盘事件，其值为0x112。
#define CONSOLE_SHELL_EXITED 0x400//表示shell已退出，其值为0x400。
#define CONSOLE_CONTROL_RIGHTS_CAPTURE 201//表示控制权被捕获，其值为201。
#define CONSOLE_CONTROL_RIGHTS_RELEASE 202//表示控制权被释放，其值为202。
#define CONSOLE_CONTROL_CAPTURE_LINE 203//表示捕获行命令，其值为203。
#define CONSOLE_CONTROL_CAPTURE_CHAR 204//表示捕获字符命令，其值为204。
#define CONSOLE_FIFO_SIZE 1024//表示控制台FIFO（First In First Out）缓冲区大小，其值为1024。
#define CONSOLE_NUM 2//表示控制台数量，其值为2。
typedef struct {
Ringbuf ringbuf; /* Ring buffer */
EVENT_CB_S sendEvent; /* Inform telnet send task */
Ringbuf ringbuf; /* Ring buffer *///表示环形缓冲区，它可能是一个用于缓存数据的循环队列或者环形链表。
EVENT_CB_S sendEvent; /* Inform telnet send task *///表示向telnet发送任务发送事件的回调函数。
} RingbufSendCB;
typedef struct {
UINT32 consoleID;
UINT32 consoleType;
UINT32 consoleSem;
UINT32 shellEntryId;
UINT32 consoleMask;
struct inode *devInode;
CHAR *name;
INT32 fd;
UINT32 refCount;
BOOL isNonBlock;
UINT32 consoleID;//表示控制台的ID。
UINT32 consoleType;//表示控制台的类型。
UINT32 consoleSem;//表示用于同步的控制台信号量。
UINT32 shellEntryId;//表示shell的入口ID。
UINT32 consoleMask;//表示控制台的掩码。
struct inode *devInode;//表示设备节点。
CHAR *name;//表示控制台的名称。
INT32 fd;//表示文件描述符。
UINT32 refCount;//表示引用计数。
BOOL isNonBlock;//表示是否为非阻塞模式。
#ifdef LOSCFG_SHELL
VOID *shellHandle;
VOID *shellHandle;//表示shell的句柄。
#endif
UINT32 sendTaskID;
RingbufSendCB *ringbufSendCB;
UINT8 fifo[CONSOLE_FIFO_SIZE];
UINT32 fifoOut;
UINT32 fifoIn;
UINT32 currentLen;
struct termios consoleTermios;
UINT32 sendTaskID;//表示发送任务的ID。
RingbufSendCB *ringbufSendCB;//表示环形缓冲区发送回调。
UINT8 fifo[CONSOLE_FIFO_SIZE];//表示控制台的FIFO缓冲区。
UINT32 fifoOut;//表示FIFO缓冲区的输出位置。
UINT32 fifoIn;//表示FIFO缓冲区的输入位置。
UINT32 currentLen;//表示当前长度。
struct termios consoleTermios;//表示控制台的终端属性。
} CONSOLE_CB;
extern INT32 system_console_init(const CHAR *deviceName);
extern INT32 system_console_deinit(const CHAR *deviceName);
extern BOOL SetSerialNonBlock(const CONSOLE_CB *consoleCB);
extern BOOL SetSerialBlock(const CONSOLE_CB *consoleCB);
extern BOOL SetTelnetNonBlock(const CONSOLE_CB *consoleCB);
extern BOOL SetTelnetBlock(const CONSOLE_CB *consoleCB);
extern CONSOLE_CB *OsGetConsoleByID(INT32 consoleId);
extern CONSOLE_CB *OsGetConsoleByTaskID(UINT32 taskId);
extern UINT32 ConsoleTaskReg(INT32 consoleId, UINT32 taskId);
extern INT32 ConsoleUpdateFd(VOID);
extern BOOL ConsoleEnable(VOID);
extern BOOL is_nonblock(const CONSOLE_CB *consoleCB);
extern BOOL IsConsoleOccupied(const CONSOLE_CB *consoleCB);
extern INT32 FilepOpen(struct file *filep, const struct file_operations_vfs *fops);
extern INT32 FilepClose(struct file *filep, const struct file_operations_vfs *fops);
extern INT32 FilepRead(struct file *filep, const struct file_operations_vfs *fops, CHAR *buffer, size_t bufLen);
extern INT32 FilepWrite(struct file *filep, const struct file_operations_vfs *fops, const CHAR *buffer, size_t bufLen);
extern INT32 FilepPoll(struct file *filep, const struct file_operations_vfs *fops, poll_table *fds);
extern INT32 FilepIoctl(struct file *filep, const struct file_operations_vfs *fops, INT32 cmd, unsigned long arg);
extern INT32 GetFilepOps(const struct file *filep, struct file **privFilep, const struct file_operations_vfs **fops);
extern INT32 system_console_init(const CHAR *deviceName);//控制台初始化函数用于初始化控制台相关的资源和状态
extern INT32 system_console_deinit(const CHAR *deviceName);//控制台反初始化函数，用于释放控制台相关的资源和状态。
extern BOOL SetSerialNonBlock(const CONSOLE_CB *consoleCB);//设置串口为非阻塞模式。
extern BOOL SetSerialBlock(const CONSOLE_CB *consoleCB);//设置串口为阻塞模式。
extern BOOL SetTelnetNonBlock(const CONSOLE_CB *consoleCB);//设置Telnet连接为非阻塞模式。
extern BOOL SetTelnetBlock(const CONSOLE_CB *consoleCB);//设置Telnet连接为阻塞模式。
extern CONSOLE_CB *OsGetConsoleByID(INT32 consoleId);//根据控制台ID获取控制台的控制块（Control Block）。
extern CONSOLE_CB *OsGetConsoleByTaskID(UINT32 taskId);//根据任务ID获取关联的控制台的控制块。
extern UINT32 ConsoleTaskReg(INT32 consoleId, UINT32 taskId);//将任务与指定的控制台进行关联。
extern INT32 ConsoleUpdateFd(VOID);//更新控制台的文件描述符（File Descriptor）。
extern BOOL ConsoleEnable(VOID);//使能控制台功能。
extern BOOL is_nonblock(const CONSOLE_CB *consoleCB);//判断控制台是否为非阻塞模式。
extern BOOL IsConsoleOccupied(const CONSOLE_CB *consoleCB);//判断控制台是否已经被占用。
extern INT32 FilepOpen(struct file *filep, const struct file_operations_vfs *fops);//打开文件。
extern INT32 FilepClose(struct file *filep, const struct file_operations_vfs *fops);//关闭文件。
extern INT32 FilepRead(struct file *filep, const struct file_operations_vfs *fops, CHAR *buffer, size_t bufLen);//从文件中读取数据。
extern INT32 FilepWrite(struct file *filep, const struct file_operations_vfs *fops, const CHAR *buffer, size_t bufLen);//向文件中写入数据。
extern INT32 FilepPoll(struct file *filep, const struct file_operations_vfs *fops, poll_table *fds);//对文件进行轮询操作。
extern INT32 FilepIoctl(struct file *filep, const struct file_operations_vfs *fops, INT32 cmd, unsigned long arg);//对文件进行IO控制操作。
extern INT32 GetFilepOps(const struct file *filep, struct file **privFilep, const struct file_operations_vfs **fops);//获取文件的操作函数。
#else
STATIC INLINE INT32 ConsoleUpdateFd(VOID)
STATIC INLINE INT32 ConsoleUpdateFd(VOID)//这是一个函数声明，声明了一个名为ConsoleUpdateFd的静态内联函数，返回类型为INT32（32位整数），参数为空。根据函数体的实现为return -1;，该函数的作用是更新控制台的文件描述符（File Descriptor），并返回-1。
{
return -1;
}
#endif
#endif//这个宏表示结束了之前的条件编译指令#if。
#ifdef __cplusplus
#ifdef __cplusplus//这一组条件编译指令用于判断是否为C++编译环境。如果是C++编译环境，则将后面的代码块用extern "C"包裹起来，以保证C和C++之间的函数调用规则一致。
#if __cplusplus
}
#endif /* __cplusplus */

46
src/kernel/include/los_atomic.h
Unescape View File

@ -30,12 +30,12 @@
* @defgroup los_atomic Atomic
* @ingroup kernel
*/
#ifndef _LOS_ATOMIC_H
#define _LOS_ATOMIC_H
//los_atomic.h是用于支持原子操作的头文件。
#ifndef _LOS_ATOMIC_H//表示如果宏变量 _LOS_ATOMIC_H 没有被定义过，则执行以下代码，否则忽略这段代码。
#define _LOS_ATOMIC_H//是定义一个宏变量，可以用来判断这个头文件是否已经被包含过。
#include "los_typedef.h"
#include "arch/atomic.h"
#include "arch/atomic.h"//是平台相关的原子操作头文件，具体实现依赖于不同的硬件平台。
#ifdef __cplusplus
#if __cplusplus
@ -60,7 +60,7 @@ extern "C" {
* @see LOS_Atomic64Read
* @since Huawei LiteOS V200R003C00
*/
STATIC INLINE INT32 LOS_AtomicRead(const Atomic *v)
STATIC INLINE INT32 LOS_AtomicRead(const Atomic *v)//函数接受一个Atomic类型的指针参数v，并返回一个32位整数。用于读取指定内存位置的原子变量的值。
{
return ArchAtomicRead(v);
}
@ -84,7 +84,7 @@ STATIC INLINE INT32 LOS_AtomicRead(const Atomic *v)
* @see LOS_Atomic64Set
* @since Huawei LiteOS V200R003C00
*/
STATIC INLINE VOID LOS_AtomicSet(Atomic *v, INT32 setVal)
STATIC INLINE VOID LOS_AtomicSet(Atomic *v, INT32 setVal)//函数接受一个Atomic类型的指针参数v和一个32位整数setVal，没有返回值（返回类型为VOID）。
{
ArchAtomicSet(v, setVal);
}
@ -114,7 +114,7 @@ STATIC INLINE VOID LOS_AtomicSet(Atomic *v, INT32 setVal)
*/
STATIC INLINE INT32 LOS_AtomicAdd(Atomic *v, INT32 addVal)
{
return ArchAtomicAdd(v, addVal);
return ArchAtomicAdd(v, addVal);//用于将指定内存位置的原子变量增加指定的值。
}
/**
@ -142,7 +142,7 @@ STATIC INLINE INT32 LOS_AtomicAdd(Atomic *v, INT32 addVal)
*/
STATIC INLINE INT32 LOS_AtomicSub(Atomic *v, INT32 subVal)
{
return ArchAtomicSub(v, subVal);
return ArchAtomicSub(v, subVal);//用于将指定内存位置的原子变量减少指定的值。
}
/**
@ -168,7 +168,7 @@ STATIC INLINE INT32 LOS_AtomicSub(Atomic *v, INT32 subVal)
*/
STATIC INLINE VOID LOS_AtomicInc(Atomic *v)
{
ArchAtomicInc(v);
ArchAtomicInc(v);//用于将指定内存位置的原子变量增加1。
}
/**
@ -222,7 +222,7 @@ STATIC INLINE INT32 LOS_AtomicIncRet(Atomic *v)
*/
STATIC INLINE VOID LOS_AtomicDec(Atomic *v)
{
ArchAtomicDec(v);
ArchAtomicDec(v);//该函数通常是由特定的体系结构提供的原子递减函数的实现。通过使用内联函数和宏定义，可以在编译时将这段代码直接嵌入到调用处，从而提高执行效率和节省函数调用的开销。
}
/**
@ -248,7 +248,7 @@ STATIC INLINE VOID LOS_AtomicDec(Atomic *v)
*/
STATIC INLINE INT32 LOS_AtomicDecRet(Atomic *v)
{
return ArchAtomicDecRet(v);
return ArchAtomicDecRet(v);//该函数通常是由特定的体系结构提供的原子递减操作并返回递减后的值的函数。
}
/**
@ -270,7 +270,7 @@ STATIC INLINE INT32 LOS_AtomicDecRet(Atomic *v)
*/
STATIC INLINE INT64 LOS_Atomic64Read(const Atomic64 *v)
{
return ArchAtomic64Read(v);
return ArchAtomic64Read(v);//该函数通常是由特定的体系结构提供的原子读取操作的函数。
}
/**
@ -294,7 +294,7 @@ STATIC INLINE INT64 LOS_Atomic64Read(const Atomic64 *v)
*/
STATIC INLINE VOID LOS_Atomic64Set(Atomic64 *v, INT64 setVal)
{
ArchAtomic64Set(v, setVal);
ArchAtomic64Set(v, setVal);//该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -322,7 +322,7 @@ STATIC INLINE VOID LOS_Atomic64Set(Atomic64 *v, INT64 setVal)
*/
STATIC INLINE INT64 LOS_Atomic64Add(Atomic64 *v, INT64 addVal)
{
return ArchAtomic64Add(v, addVal);
return ArchAtomic64Add(v, addVal);//函数来完成原子加操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -350,7 +350,7 @@ STATIC INLINE INT64 LOS_Atomic64Add(Atomic64 *v, INT64 addVal)
*/
STATIC INLINE INT64 LOS_Atomic64Sub(Atomic64 *v, INT64 subVal)
{
return ArchAtomic64Sub(v, subVal);
return ArchAtomic64Sub(v, subVal);//函数来完成原子减操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -376,7 +376,7 @@ STATIC INLINE INT64 LOS_Atomic64Sub(Atomic64 *v, INT64 subVal)
*/
STATIC INLINE VOID LOS_Atomic64Inc(Atomic64 *v)
{
ArchAtomic64Inc(v);
ArchAtomic64Inc(v);//函数来完成原子增加操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -403,7 +403,7 @@ STATIC INLINE VOID LOS_Atomic64Inc(Atomic64 *v)
*/
STATIC INLINE INT64 LOS_Atomic64IncRet(Atomic64 *v)
{
return ArchAtomic64IncRet(v);
return ArchAtomic64IncRet(v);//函数来完成原子增加操作并返回增加后的值，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -430,7 +430,7 @@ STATIC INLINE INT64 LOS_Atomic64IncRet(Atomic64 *v)
*/
STATIC INLINE VOID LOS_Atomic64Dec(Atomic64 *v)
{
ArchAtomic64Dec(v);
ArchAtomic64Dec(v);//函数来完成原子减少操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -456,7 +456,7 @@ STATIC INLINE VOID LOS_Atomic64Dec(Atomic64 *v)
*/
STATIC INLINE INT64 LOS_Atomic64DecRet(Atomic64 *v)
{
return ArchAtomic64DecRet(v);
return ArchAtomic64DecRet(v);//函数来完成原子减少操作并返回减少后的值，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -480,7 +480,7 @@ STATIC INLINE INT64 LOS_Atomic64DecRet(Atomic64 *v)
*/
STATIC INLINE INT32 LOS_AtomicXchg32bits(Atomic *v, INT32 val)
{
return ArchAtomicXchg32bits(v, val);
return ArchAtomicXchg32bits(v, val);//函数来完成原子交换操作并返回交换前的值，该函数应该是由底层的架构代码提供的，用于实现 32 位整数的原子操作。
}
/**
@ -504,7 +504,7 @@ STATIC INLINE INT32 LOS_AtomicXchg32bits(Atomic *v, INT32 val)
*/
STATIC INLINE INT64 LOS_AtomicXchg64bits(Atomic64 *v, INT64 val)
{
return ArchAtomicXchg64bits(v, val);
return ArchAtomicXchg64bits(v, val);//函数来完成原子交换操作并返回交换前的值，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
/**
@ -531,7 +531,7 @@ STATIC INLINE INT64 LOS_AtomicXchg64bits(Atomic64 *v, INT64 val)
*/
STATIC INLINE BOOL LOS_AtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal)
{
return ArchAtomicCmpXchg32bits(v, val, oldVal);
return ArchAtomicCmpXchg32bits(v, val, oldVal);//函数来完成原子比较和交换操作，并返回比较结果，该函数应该是由底层的架构代码提供的，用于实现 32 位整数的原子操作。
}
/**
@ -558,7 +558,7 @@ STATIC INLINE BOOL LOS_AtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal)
*/
STATIC INLINE BOOL LOS_AtomicCmpXchg64bits(Atomic64 *v, INT64 val, INT64 oldVal)
{
return ArchAtomicCmpXchg64bits(v, val, oldVal);
return ArchAtomicCmpXchg64bits(v, val, oldVal);//函数来完成原子比较和交换操作，并返回比较结果，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。
}
#ifdef __cplusplus

43
src/kernel/include/los_base.h
Unescape View File

@ -75,19 +75,19 @@ extern "C" {
* @since Huawei LiteOS V100R001C00
*/
#define LOS_ASSERT_COND(expression) LOS_ASSERT(expression)
//这是一个宏函数，它接受一个表达式作为参数，并将该表达式作为参数传递给另一个名为LOS_ASSERT的宏函数。它的作用是在满足给定条件时执行断言。
/**
* @ingroup los_base
* Define the timeout interval as LOS_NO_WAIT.
*/
#define LOS_NO_WAIT 0
//这是一个常量，被定义为0。它表示一个超时时间间隔，即表示不等待，立即返回。
/**
* @ingroup los_base
* Define the timeout interval as LOS_WAIT_FOREVER.
*/
#define LOS_WAIT_FOREVER 0xFFFFFFFF
//这是另一个常量，被定义为0xFFFFFFFF。它表示一个超时时间间隔，即表示永远等待，直到条件满足或者被中断。
/**
* @ingroup los_base
* @brief Align the value (addr) by some bytes (boundary).
@ -111,8 +111,8 @@ extern "C" {
* @see LOS_Align | TRUNCATE
* @since Huawei LiteOS V100R001C00
*/
#ifndef ALIGN
#define ALIGN(addr, boundary) LOS_Align(addr, boundary)
#ifndef ALIGN//判断ALIGN是否已经被定义过，如果没有被定义过，则执行接下来的代码。
#define ALIGN(addr, boundary) LOS_Align(addr, boundary)//分别表示需要对齐的地址和对齐边界。在函数体内部，它调用了LOS_Align函数进行地址对齐操作，将addr地址向上对齐到最接近的boundary的倍数。
#endif
/**
@ -139,10 +139,16 @@ extern "C" {
* @since Huawei LiteOS V100R001C00
*/
#define TRUNCATE(addr, size) ((UINTPTR)(addr) & ~((size) - 1))
//宏接受两个参数 addr 和 size，返回一个截断后的地址。具体而言，该宏将地址 addr 按照 size 的大小进行对齐，并将低位多余的位置为零。例如，如果 addr 是 0x12345678，size 是 4，则截断后的地址是 0x12345670。
/**
* Read a UINT8 value from addr and stroed in value.
*/
/*READ_UINT8(value, addr)、READ_UINT16(value, addr) 和 READ_UINT32(value, addr)
分别用于从地址 addr 中读取 8 位、16 位和 32 位的数值，
并将结果存储到变量 value 中。这几个宏的实现方式类似，
都是通过指针间接读取内存中的数值，并使用 dsb() 函数进行数据同步操作，
以确保读取的数据正确。其中，dsb() 函数是一个汇编指令，
用于进行数据同步操作，防止出现数据不一致的情况。*/
#define READ_UINT8(value, addr) ({ (value) = *((volatile UINT8 *)((UINTPTR)(addr))); dsb(); })
/**
@ -155,6 +161,9 @@ extern "C" {
*/
#define READ_UINT32(value, addr) ({ (value) = *((volatile UINT32 *)((UINTPTR)(addr))); dsb(); })
//判断编译环境是否为 64 位。如果是 64 位环境，则定义了 READ_UINT64 和 WRITE_UINT64 宏。否则，这两个宏将被忽略。
//宏用于从地址 addr 中读取一个 64 位的整数值，并将结果存储到变量 value 中。这里使用了和之前类似的操作，通过指针间接读取内存中的值，并使用 dsb() 函数进行数据同步操作。
#ifdef __LP64__
/**
* Read a UINT64 value from addr and stroed in value.
@ -162,6 +171,11 @@ extern "C" {
#define READ_UINT64(value, addr) ({ (value) = *((volatile UINT64 *)((UINTPTR)(addr))); dsb(); })
#endif
/*WRITE_UINT8(value, addr)、WRITE_UINT16(value, addr) 和 WRITE_UINT32(value, addr) 宏
分别用于将 8 位、16 位和 32 位的整数值 value 写入到地址 addr 中。
这些宏也使用了和之前类似的操作，使用 dsb() 函数进行数据同步操作，
并通过指针间接写入内存中的值。*/
/**
* Write a UINT8 value to addr.
*/
@ -177,6 +191,8 @@ extern "C" {
*/
#define WRITE_UINT32(value, addr) ({ dsb(); *((volatile UINT32 *)((UINTPTR)(addr))) = (value); })
//在 64 位环境下，还定义了 WRITE_UINT64 宏，用于将 64 位的整数值 value 写入到地址 addr 中。
#ifdef __LP64__
/**
* Write a UINT64 addr to addr.
@ -187,11 +203,13 @@ extern "C" {
/**
* Get a UINT8 value from addr.
*/
//宏用于从地址 addr 中读取一个 8 位的无符号整数值，并返回读取到的结果。在读取之后，使用 dsb() 函数进行数据同步操作，以确保读取的数据正确。
#define GET_UINT8(addr) ({ UINT8 r = *((volatile UINT8 *)((UINTPTR)(addr))); dsb(); r; })
/**
* Get a UINT16 value from addr.
*/
//GET_UINT16(addr) 和 GET_UINT32(addr) 宏分别用于从地址 addr 中读取 16 位和 32 位的无符号整数值，并返回读取到的结果。同样地，在读取之后也进行数据同步操作。
#define GET_UINT16(addr) ({ UINT16 r = *((volatile UINT16 *)((UINTPTR)(addr))); dsb(); r; })
/**
@ -199,6 +217,8 @@ extern "C" {
*/
#define GET_UINT32(addr) ({ UINT32 r = *((volatile UINT32 *)((UINTPTR)(addr))); dsb(); r; })
//在 64 位环境下，还定义了 GET_UINT64(addr) 宏，用于从地址 addr 中读取一个 64 位的无符号整数值，并返回读取到的结果。
#ifdef __LP64__
/**
* Get a UINT64 value from addr.
@ -226,7 +246,7 @@ extern "C" {
* @see LOS_ASSERT_COND
* @since Huawei LiteOS V100R001C00
*/
#ifdef LOSCFG_DEBUG_VERSION
#ifdef LOSCFG_DEBUG_VERSION//首先，通过条件编译指令 #ifdef LOSCFG_DEBUG_VERSION 来判断是否处于调试版本。如果定义了 LOSCFG_DEBUG_VERSION 宏，则表示处于调试版本，代码块 #ifdef 和 #endif 之间的内容将会生效；否则，代码块 #else 和 #endif 之间的内容将会生效。
#define LOS_ASSERT(judge) do { \
if ((UINTPTR)(judge) == 0) { \
(VOID)LOS_IntLock(); \
@ -234,8 +254,12 @@ extern "C" {
while (1) {} \
} \
} while (0)
//在调试版本下，宏定义的代码块中，LOS_ASSERT 宏被定义为一个带有参数 judge 的宏函数。它的作用是进行断言检查，如果 judge 表达式的结果为零（即假），则执行以上操作
//调用 LOS_IntLock() 函数，该函数可能是一个用于禁止中断的操作，以确保在断言失败时不会中断处理。
//使用 PRINT_ERR 打印一条错误信息，其中包含了出错的文件名、行号和函数名。
//进入一个无限循环 while (1)，程序会一直停留在这个循环中。
#else
#define LOS_ASSERT(judge)
#define LOS_ASSERT(judge)//在非调试版本下，宏定义的代码块中，LOS_ASSERT 宏被定义为空，即不进行任何操作。
#endif
/**
@ -261,7 +285,8 @@ extern "C" {
* @since Huawei LiteOS V100R001C00
*/
extern UINTPTR LOS_Align(UINTPTR addr, UINT32 boundary);
//具体而言，函数的功能是将 addr 按照 boundary 边界进行对齐，并返回对齐后的地址。例如，如果 addr 是 12，boundary 是 8，那么对齐后的地址就是 16。
//extern 关键字表示该函数是在其他地方定义的，这里只是对其进行声明。这样做的目的是在当前文件中使用该函数时能够正确引用它，而不需要提供函数的具体实现。
/**
* @ingroup los_base
* @brief Sleep the current task.

21
src/kernel/include/los_bitmap.h
Unescape View File

@ -31,7 +31,7 @@
* @ingroup kernel
*/
#ifndef _LOS_BITMAP_H
#ifndef _LOS_BITMAP_H//这段代码是一个条件编译指令块，用于判断是否定义了宏 _LOS_BITMAP_H。如果未定义该宏，则会执行 #ifndef 和 #endif 之间的代码。
#define _LOS_BITMAP_H
#include "los_typedef.h"
@ -48,6 +48,7 @@ extern "C" {
*
* The effective bit index is from 0 to 31.
*/
//由于这里宏定义的值为 32，这个宏的含义是使用 0 到 31 的整数表示位索引值，而 32 则表示无效的位索引值。这种处理方式在计算机编程中比较常见，一般用于标识某些特殊的状态或标志。
#define LOS_INVALID_BIT_INDEX 32
/**
@ -69,6 +70,9 @@ extern "C" {
* @see LOS_BitmapClr
* @since Huawei LiteOS V100R001C00
*/
/*bitmap 是一个指向 UINT32 类型的指针，表示一个位图（或称为位数组）。
pos 是一个 UINT16 类型的参数，表示要设置的位索引。
函数的作用是在给定的位图中将指定的位索引位置设为 1，即将相应位置的比特位设置为 1。*/
VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos);
/**
@ -90,6 +94,9 @@ VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos);
* @see LOS_BitmapSet.
* @since Huawei LiteOS V100R001C00
*/
/*bitmap 是一个指向 UINT32 类型的指针，表示一个位图（或称为位数组）。
pos 是一个 UINT16 类型的参数，表示要清除的位索引。
函数的作用是在给定的位图中将指定的位索引位置清零，即将相应位置的比特位设置为 0。*/
VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos);
/**
@ -108,6 +115,12 @@ VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos);
* @see LOS_HighBitGet
* @since Huawei LiteOS V100R001C00
*/
/*函数的作用是在给定的位图中找到最低位（也就是数值最小的位）的索引，
并返回该索引。如果位图中不存在任何置位的比特位，
则返回 32，即宏 LOS_INVALID_BIT_INDEX 的值。
具体实现可能会涉及位运算和掩码操作，
以找到最低位的索引号。由于函数返回类型为 UINT16，
即 unsigned short 类型，因此返回值为 0 到 31 的整数（包括 0 和 31）或 32*/
UINT16 LOS_LowBitGet(UINT32 bitmap);
/**
@ -126,6 +139,12 @@ UINT16 LOS_LowBitGet(UINT32 bitmap);
* @see LOS_LowBitGet
* @since Huawei LiteOS V100R001C00
*/
/*函数的作用是在给定的位图中找到最高位（也就是数值最大的位）的索引，
并返回该索引。如果位图中不存在任何置位的比特位，
则返回 32，即宏 LOS_INVALID_BIT_INDEX 的值。
具体实现可能会涉及位运算和掩码操作，以找到最高位的索引号。
由于函数返回类型为 UINT16，即 unsigned short 类型，
因此返回值为 0 到 31 的整数（包括 0 和 31）或 32。*/
UINT16 LOS_HighBitGet(UINT32 bitmap);
#ifdef __cplusplus

42
src/kernel/include/los_builddef.h
Unescape View File

@ -35,79 +35,79 @@ extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#define OS_LITTLE_ENDIAN 0x1234 /* Little endian */
#define OS_BIG_ENDIAN 0x4321 /* Big endian */
#define OS_LITTLE_ENDIAN 0x1234 /* Little endian *///表示小端序，数值为 0x1234
#define OS_BIG_ENDIAN 0x4321 /* Big endian *///表示大端序，数值为 0x4321
#ifndef OS_BYTE_ORDER
#define OS_BYTE_ORDER OS_LITTLE_ENDIAN
#define OS_BYTE_ORDER OS_LITTLE_ENDIAN//如果未定义 OS_BYTE_ORDER，则将其设置为 OS_LITTLE_ENDIAN
#endif
/* Define OS code data sections */
/* The indicator function is inline */
#ifndef LITE_OS_SEC_ALW_INLINE
#define LITE_OS_SEC_ALW_INLINE /* __attribute__((always_inline)) */
#define LITE_OS_SEC_ALW_INLINE /* __attribute__((always_inline)) *///定义了一个宏，用于将函数声明为内联函数
#endif
#ifndef LITE_OS_SEC_TEXT
#define LITE_OS_SEC_TEXT /* __attribute__((section(".text.sram"))) */
#define LITE_OS_SEC_TEXT /* __attribute__((section(".text.sram"))) *///定义了一个宏，用于将代码段放置在 .text.sram 段中
#endif
#ifndef LITE_OS_SEC_TEXT_MINOR
#define LITE_OS_SEC_TEXT_MINOR /* __attribute__((section(".text.ddr"))) */
#define LITE_OS_SEC_TEXT_MINOR /* __attribute__((section(".text.ddr"))) *///定义了一个宏，用于将代码段放置在 .text.ddr 段中
#endif
#ifndef LITE_OS_SEC_TEXT_INIT
#define LITE_OS_SEC_TEXT_INIT /* __attribute__((section(".text.init"))) */
#define LITE_OS_SEC_TEXT_INIT /* __attribute__((section(".text.init"))) *///宏定义了一个代码段，用于放置初始化代码，其位置在 .text.init 段中。
#endif
#ifndef LITE_OS_SEC_DATA
#define LITE_OS_SEC_DATA /* __attribute__((section(".data.sram"))) */
#define LITE_OS_SEC_DATA /* __attribute__((section(".data.sram"))) *///宏定义了一个数据段，用于放置数据，其位置在 .data.sram 段中。
#endif
#ifndef LITE_OS_SEC_DATA_MINOR
#define LITE_OS_SEC_DATA_MINOR /* __attribute__((section(".data.ddr"))) */
#define LITE_OS_SEC_DATA_MINOR /* __attribute__((section(".data.ddr"))) *///定义了一个次要数据段，用于放置次要的数据，其位置在 .data.ddr 段中。
#endif
#ifndef LITE_OS_SEC_DATA_INIT
#define LITE_OS_SEC_DATA_INIT /* __attribute__((section(".data.init"))) */
#define LITE_OS_SEC_DATA_INIT /* __attribute__((section(".data.init"))) *///宏定义了一个数据段，用于放置初始化数据，其位置在 .data.init 段中。
#endif
#ifndef LITE_OS_SEC_DATA_VEC
#define LITE_OS_SEC_DATA_VEC __attribute__((section(".data.vector")))
#define LITE_OS_SEC_DATA_VEC __attribute__((section(".data.vector")))//宏定义了一个数据段，用于放置向量表数据，其位置在 .data.vector 段中。
#endif
#ifndef LITE_OS_SEC_BSS
#define LITE_OS_SEC_BSS /* __attribute__((section(".bss.sram"))) */
#define LITE_OS_SEC_BSS /* __attribute__((section(".bss.sram"))) *///宏定义了一个数据段，用于放置未初始化的数据（BSS段），其位置在 .bss.sram 段中。
#endif
#ifndef LITE_OS_SEC_BSS_MINOR
#define LITE_OS_SEC_BSS_MINOR /* __attribute__((section(".bss.ddr"))) */
#define LITE_OS_SEC_BSS_MINOR /* __attribute__((section(".bss.ddr"))) */// 宏定义了一个数据段，用于放置未初始化的次要数据（BSS段），其位置在 .bss.ddr 段中。
#endif
#ifndef LITE_OS_SEC_BSS_INIT
#define LITE_OS_SEC_BSS_INIT /* __attribute__((section(".bss.init"))) */
#define LITE_OS_SEC_BSS_INIT /* __attribute__((section(".bss.init"))) *///宏定义了一个数据段，用于放置未初始化的初始化数据（BSS段），其位置在 .bss.init 段中。
#endif
#ifndef LITE_OS_SEC_ITCM
#define LITE_OS_SEC_ITCM /* __attribute__((section(".itcm "))) */
#define LITE_OS_SEC_ITCM /* __attribute__((section(".itcm "))) */// 宏定义了一个代码段，用于放置代码（指令）和只读数据，在 ITCM 中运行。 ITCM 与其他内存有所不同，它位于 CPU 内部，具有高速访问和低延迟的优势。
#endif
#ifndef LITE_OS_SEC_DTCM
#define LITE_OS_SEC_DTCM /* __attribute__((section(".dtcm"))) */
#define LITE_OS_SEC_DTCM /* __attribute__((section(".dtcm"))) *///宏定义了一个数据段，用于放置数据，位于 DTCM 中。 DTCM 与其他内存有所不同，它位于 CPU 内部，具有高速访问和低延迟的优势。
#endif
#define PACK1
#define PACK1//宏定义了一个结构体成员变量的对齐方式，将结构体的成员变量紧密地打包在一起，不使用空间来对齐。
#ifndef LITE_OS_ATTR_SEC
#define LITE_OS_ATTR_SEC(name) __attribute__((section(#name)))
#define LITE_OS_ATTR_SEC(name) __attribute__((section(#name)))//宏定义了一个函数或变量所在的段，通过 #name 将 name 转换为字符串，将函数或变量放置到指定名称的段中。
#endif
#ifndef LITE_OS_ATTR_ALIGN
#define LITE_OS_ATTR_ALIGN(x) __attribute__((aligned(x)))
#define LITE_OS_ATTR_ALIGN(x) __attribute__((aligned(x)))//宏定义了数据的对齐方式，即几个字节对齐，x 表示对齐的字节数。
#endif
#ifndef LITE_OS_ATTR_SEC_ALIGN
#define LITE_OS_ATTR_SEC_ALIGN(name, x) __attribute__((section(#name), aligned(x)))
#define LITE_OS_ATTR_SEC_ALIGN(name, x) __attribute__((section(#name), aligned(x)))//宏定义了某段数据的对齐方式，即将数据放置到指定名称的段中，并按照指定的对齐方式对齐。
#endif
#ifndef OS_EMBED_ASM
#define OS_EMBED_ASM __asm__ __volatile__
#define OS_EMBED_ASM __asm__ __volatile__//宏定义了嵌入汇编指令的方式，将 asm volatile 作为嵌入汇编指令的前缀，使得编译器可以将其识别为汇编指令。
#endif
#ifdef __cplusplus

216
src/kernel/include/los_config.h
Unescape View File

@ -30,6 +30,22 @@
* @defgroup los_config System configuration items
* @ingroup kernel
*/
/*具体而言，los_config.h 文件通常包含以下内容：
任务（Task）配置：可以定义任务的数量、优先级范围、堆栈大小等参数，以满足不同应用场景的需求。
中断（Interrupt）配置：可以定义中断服务例程的数量、优先级范围，以及中断处理的策略等。
内存管理（Memory Management）配置：可以定义动态内存分配算法、内存池的大小和数量等相关参数。
定时器（Timer）配置：可以定义定时器的数量、精度、触发方式等。
任务调度（Task Scheduling）配置：可以配置任务调度算法、时间片轮转的时间等。
系统时钟（System Clock）配置：可以定义系统时钟的频率、定时器的输入时钟源等。
通过修改 los_config.h 文件中的宏定义和全局变量，开发人员可以根据应用需求对操作系统进行定制和优化。
然后，将修改后的 los_config.h 文件编译进入 LiteOS 内核，即可实现对操作系统行为和功能的定制化配置。*/
#ifndef _LOS_CONFIG_H
#define _LOS_CONFIG_H
@ -45,53 +61,53 @@ extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#ifdef LOSCFG_LIB_CONFIGURABLE
extern UINT32 g_osSysClock;
extern UINT32 g_tickPerSecond;
extern UINT32 g_taskLimit;
extern UINT32 g_taskMinStkSize;
extern UINT32 g_taskIdleStkSize;
extern UINT32 g_taskDfltStkSize;
extern UINT32 g_taskSwtmrStkSize;
extern UINT32 g_swtmrLimit;
extern UINT32 g_semLimit;
extern UINT32 g_muxLimit;
extern UINT32 g_queueLimit;
extern UINT32 g_timeSliceTimeOut;
extern BOOL g_nxEnabled;
extern UINTPTR g_dlNxHeapBase;
extern UINT32 g_dlNxHeapSize;
#define LOS_GET_NX_CFG() (g_nxEnabled)
#define LOS_SET_NX_CFG(value) (g_nxEnabled = (value))
#define LOS_GET_DL_NX_HEAP_BASE() (g_dlNxHeapBase)
#define LOS_SET_DL_NX_HEAP_BASE(addr) (g_dlNxHeapBase = (addr))
#define LOS_GET_DL_NX_HEAP_SIZE() (g_dlNxHeapSize)
#define LOS_SET_DL_NX_HEAP_SIZE(size) (g_dlNxHeapSize = (size))
#define OS_SYS_CLOCK g_osSysClock
#define KERNEL_TICK_PER_SECOND g_tickPerSecond
#define KERNEL_TSK_LIMIT g_taskLimit
#define KERNEL_TSK_MIN_STACK_SIZE g_taskMinStkSize
#define KERNEL_TSK_DEFAULT_STACK_SIZE g_taskDfltStkSize
#define KERNEL_TSK_IDLE_STACK_SIZE g_taskIdleStkSize
#define KERNEL_TSK_SWTMR_STACK_SIZE g_taskSwtmrStkSize
#define KERNEL_SWTMR_LIMIT g_swtmrLimit
#define KERNEL_SEM_LIMIT g_semLimit
#define KERNEL_MUX_LIMIT g_muxLimit
#define KERNEL_QUEUE_LIMIT g_queueLimit
#define KERNEL_TIMESLICE_TIMEOUT g_timeSliceTimeOut
#ifdef LOSCFG_LIB_CONFIGURABLE//判断宏定义 LOSCFG_LIB_CONFIGURABLE 是否被定义。如果该宏被定义，那么以下变量声明将会被编译进程序中。
extern UINT32 g_osSysClock;//系统时钟频率
extern UINT32 g_tickPerSecond;//系统时钟滴答数
extern UINT32 g_taskLimit;//最大任务数量
extern UINT32 g_taskMinStkSize;//任务最小堆栈大小
extern UINT32 g_taskIdleStkSize;//空闲任务堆栈大小
extern UINT32 g_taskDfltStkSize;//默认任务堆栈大小
extern UINT32 g_taskSwtmrStkSize;//软件定时器任务堆栈大小
extern UINT32 g_swtmrLimit;//最大软件定时器数量
extern UINT32 g_semLimit;//最大信号量数量
extern UINT32 g_muxLimit;//最大互斥量数量
extern UINT32 g_queueLimit;//最大队列数量
extern UINT32 g_timeSliceTimeOut;//时间片轮转的时间
extern BOOL g_nxEnabled;//是否启用内存保护机制
extern UINTPTR g_dlNxHeapBase;//内存保护机制的起始地址
extern UINT32 g_dlNxHeapSize;//内存保护机制的大小
#define LOS_GET_NX_CFG() (g_nxEnabled)//宏用于获取一个名为g_nxEnabled的变量的值。
#define LOS_SET_NX_CFG(value) (g_nxEnabled = (value))//宏用于设置一个名为g_nxEnabled的变量的值。
#define LOS_GET_DL_NX_HEAP_BASE() (g_dlNxHeapBase)//宏用于获取一个名为g_dlNxHeapBase的变量的值。
#define LOS_SET_DL_NX_HEAP_BASE(addr) (g_dlNxHeapBase = (addr))//宏用于设置一个名为g_dlNxHeapBase的变量的值。
#define LOS_GET_DL_NX_HEAP_SIZE() (g_dlNxHeapSize)//宏用于获取一个名为g_dlNxHeapSize的变量的值。
#define LOS_SET_DL_NX_HEAP_SIZE(size) (g_dlNxHeapSize = (size))//宏用于设置一个名为g_dlNxHeapSize的变量的值。
#define OS_SYS_CLOCK g_osSysClock//定义系统时间频率
#define KERNEL_TICK_PER_SECOND g_tickPerSecond//定义系统时针滴答数
#define KERNEL_TSK_LIMIT g_taskLimit//定义最大任务数量
#define KERNEL_TSK_MIN_STACK_SIZE g_taskMinStkSize//定义任务最小堆栈大小
#define KERNEL_TSK_DEFAULT_STACK_SIZE g_taskDfltStkSize//定义默认任务堆栈大小
#define KERNEL_TSK_IDLE_STACK_SIZE g_taskIdleStkSize//定义默认任务堆栈大小
#define KERNEL_TSK_SWTMR_STACK_SIZE g_taskSwtmrStkSize//定义软件定时器任务堆栈大小
#define KERNEL_SWTMR_LIMIT g_swtmrLimit//定义最大软件定时器数量
#define KERNEL_SEM_LIMIT g_semLimit//定义最大信号量数量
#define KERNEL_MUX_LIMIT g_muxLimit//定义最大互斥量数量
#define KERNEL_QUEUE_LIMIT g_queueLimit//定义最大对列数量
#define KERNEL_TIMESLICE_TIMEOUT g_timeSliceTimeOut//定义时间片轮转的时间
#else /* LOSCFG_LIB_CONFIGURABLE */
#ifdef LOSCFG_KERNEL_NX
#define LOS_GET_NX_CFG() true
#define LOS_SET_NX_CFG(value)
#define LOS_GET_DL_NX_HEAP_BASE() LOS_DL_HEAP_BASE
#define LOS_SET_DL_NX_HEAP_BASE(addr)
#define LOS_GET_DL_NX_HEAP_SIZE() LOS_DL_HEAP_SIZE
#define LOS_SET_DL_NX_HEAP_SIZE(size)
#define LOS_GET_NX_CFG() true//获取内存保护机制是否开启的配置值，当 LOSCFG_KERNEL_NX 宏被定义时，返回 true；否则返回 false。
#define LOS_SET_NX_CFG(value)//设置内存保护机制的配置值，该宏定义为空白，没有实际操作。
#define LOS_GET_DL_NX_HEAP_BASE() LOS_DL_HEAP_BASE//获取内存保护机制的起始地址，当 LOSCFG_KERNEL_NX 宏被定义时，返回 LOS_DL_HEAP_BASE；否则返回 NULL。
#define LOS_SET_DL_NX_HEAP_BASE(addr)//设置内存保护机制的起始地址，该宏定义为空白，没有实际操作。
#define LOS_GET_DL_NX_HEAP_SIZE() LOS_DL_HEAP_SIZE//获取内存保护机制的大小，当 LOSCFG_KERNEL_NX 宏被定义时，返回 LOS_DL_HEAP_SIZE；否则返回 0。
#define LOS_SET_DL_NX_HEAP_SIZE(size)//设置内存保护机制的大小，该宏定义为空白，没有实际操作。
#else /* LOSCFG_KERNEL_NX */
#define LOS_GET_NX_CFG() false
#define LOS_SET_NX_CFG(value)
@ -101,7 +117,9 @@ extern UINT32 g_dlNxHeapSize;
#define LOS_SET_DL_NX_HEAP_SIZE(size)
#endif /* LOSCFG_KERNEL_NX */
#define KERNEL_TICK_PER_SECOND LOSCFG_BASE_CORE_TICK_PER_SECOND
//这段代码是一系列宏定义，用于将一些配置参数映射到对应的宏定义。
//这样做的目的是将配置参数与代码解耦，使得修改配置参数时只需要修改相应的宏定义，而无需修改引用该参数的代码。这样可以提高代码的可维护性和可移植性。
#define KERNEL_TICK_PER_SECOND LOSCFG_BASE_CORE_TICK_PER_SECOND//如KERNEL_TICK_PER_SECOND宏定义为LOSCFG_BASE_CORE_TICK_PER_SECOND，意味着在代码中使用KERNEL_TICK_PER_SECOND时，实际上是使用了配置参数
#define KERNEL_TSK_LIMIT LOSCFG_BASE_CORE_TSK_LIMIT
#define KERNEL_TSK_MIN_STACK_SIZE LOSCFG_BASE_CORE_TSK_MIN_STACK_SIZE
#define KERNEL_TSK_DEFAULT_STACK_SIZE LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE
@ -112,27 +130,27 @@ extern UINT32 g_dlNxHeapSize;
#define KERNEL_MUX_LIMIT LOSCFG_BASE_IPC_MUX_LIMIT
#define KERNEL_QUEUE_LIMIT LOSCFG_BASE_IPC_QUEUE_LIMIT
#define KERNEL_TIMESLICE_TIMEOUT LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT
//最后的#endif /* LOSCFG_LIB_CONFIGURABLE */表示这组宏定义的结束，在条件LOSCFG_LIB_CONFIGURABLE不成立时，这组宏定义不起作用，因为它们是在这个条件下定义的。
#endif /* LOSCFG_LIB_CONFIGURABLE */
/**
* system sections start and end address
*/
extern CHAR __int_stack_start;
extern CHAR __int_stack_end;
extern CHAR __rodata_start;
extern CHAR __rodata_end;
extern CHAR __bss_start;
extern CHAR __bss_end;
extern CHAR __text_start;
extern CHAR __text_end;
extern CHAR __ram_data_start;
extern CHAR __ram_data_end;
extern CHAR __exc_heap_start;
extern CHAR __exc_heap_end;
extern CHAR __heap_start;
extern CHAR __init_array_start__;
extern CHAR __init_array_end__;
extern CHAR __int_stack_start;//内部栈的起始地址
extern CHAR __int_stack_end;//内部栈的结束地址
extern CHAR __rodata_start;//只读数据段的起始地址。
extern CHAR __rodata_end;//只读数据段的结束地址。
extern CHAR __bss_start;//未初始化的全局变量段（BSS Segment）的起始地址。
extern CHAR __bss_end;//未初始化的全局变量段（BSS Segment）的结束地址。
extern CHAR __text_start;//可执行代码段（Text Segment）的起始地址。
extern CHAR __text_end;//可执行代码段（Text Segment）的结束地址。
extern CHAR __ram_data_start;//RAM 数据段的起始地址。
extern CHAR __ram_data_end;//RAM 数据段的结束地址。
extern CHAR __exc_heap_start;//异常堆（Exception Heap）的起始地址。
extern CHAR __exc_heap_end;//异常堆（Exception Heap）的结束地址。
extern CHAR __heap_start;//堆（Heap）的起始地址。
extern CHAR __init_array_start__;//初始化数组的起始地址。
extern CHAR __init_array_end__; //初始化数组的结束地址。
/****************************** System clock module configuration ****************************/
/**
@ -140,24 +158,24 @@ extern CHAR __init_array_end__;
* System clock (unit: HZ)
*/
#ifndef OS_SYS_CLOCK
#define OS_SYS_CLOCK (get_bus_clk())
#define OS_SYS_CLOCK (get_bus_clk())//定义系统时钟频率，默认值为get_bus_clk()
#endif
/**
* @ingroup los_config
* time timer clock (unit: HZ)
*/
#ifndef OS_TIME_TIMER_CLOCK
#define OS_TIME_TIMER_CLOCK OS_SYS_CLOCK
#define OS_TIME_TIMER_CLOCK OS_SYS_CLOCK//定义定时器时钟频率，默认值为 OS_SYS_CLOCK
#endif
/**
* limit addr range when search for 'func local(frame pointer)' or 'func name'
*/
#ifndef OS_SYS_FUNC_ADDR_START
#define OS_SYS_FUNC_ADDR_START ((UINTPTR)&__int_stack_start)
#define OS_SYS_FUNC_ADDR_START ((UINTPTR)&__int_stack_start)//定义函数起始地址，默认值为&__int_stack_start
#endif
#ifndef OS_SYS_FUNC_ADDR_END
#define OS_SYS_FUNC_ADDR_END g_sys_mem_addr_end
#define OS_SYS_FUNC_ADDR_END g_sys_mem_addr_end//定义函数终止地址，默认值为g_sys_mem_addr_end
#endif
/**
@ -165,14 +183,14 @@ extern CHAR __init_array_end__;
* Microseconds of adjtime in one second
*/
#ifndef LOSCFG_BASE_CORE_ADJ_PER_SECOND
#define LOSCFG_BASE_CORE_ADJ_PER_SECOND 500
#define LOSCFG_BASE_CORE_ADJ_PER_SECOND 500//每秒钟的微调时间。如果没有定义过LOSCFG_BASE_CORE_ADJ_PER_SECOND，则将其定义为500。这意味着系统在进行时间微调时，每秒钟可以微调500微秒。
#endif
/**
* @ingroup los_config
* Sched clck interval
*/
#define SCHED_CLOCK_INTETRVAL_TICKS 100
#define SCHED_CLOCK_INTETRVAL_TICKS 100//表示调度时钟的间隔。这个宏定义的值为100，表示调度时钟的间隔为100个时钟节拍。
/****************************** Interrupt module configuration ****************************/
/**
@ -184,7 +202,7 @@ extern CHAR __init_array_end__;
*/
#ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION
#ifndef MAX_BINARY_POINT_VALUE
#define MAX_BINARY_POINT_VALUE 4
#define MAX_BINARY_POINT_VALUE 4//使用条件编译来检查是否已经定义了MAX_BINARY_POINT_VALUE宏。如果没有定义，则将其定义为4。
#endif
#endif
@ -197,6 +215,11 @@ extern CHAR __init_array_end__;
* 0xFFFF: max number of all software timers
*/
#ifndef OS_SWTMR_MAX_TIMERID
/*表示软件定时器ID的最大数量。
默认值为((0xFFFF / KERNEL_SWTMR_LIMIT) * KERNEL_SWTMR_LIMIT)，
其中KERNEL_SWTMR_LIMIT表示系统中每个任务可以创建的最大软件定时器数。
这个宏定义的作用是将可用的ID数量限制在一个整数倍的软件定时器数范围内，
这样可以更好地利用ID资源。*/
#define OS_SWTMR_MAX_TIMERID ((0xFFFF / KERNEL_SWTMR_LIMIT) * KERNEL_SWTMR_LIMIT)
#endif
/**
@ -204,6 +227,11 @@ extern CHAR __init_array_end__;
* Maximum size of a software timer queue. The default value of LOSCFG_BASE_CORE_SWTMR_LIMIT is 16.
*/
#ifndef OS_SWTMR_HANDLE_QUEUE_SIZE
/*示软件定时器队列的最大大小。
默认值为KERNEL_SWTMR_LIMIT，
也就是系统中每个任务可以同时管理的软件定时器数。
这个宏定义的作用是限制任务能够管理的软件定时器数量，
以避免资源浪费和性能问题。*/
#define OS_SWTMR_HANDLE_QUEUE_SIZE KERNEL_SWTMR_LIMIT
#endif
#endif
@ -214,6 +242,10 @@ extern CHAR __init_array_end__;
* Starting address of the system memory
*/
#ifndef OS_SYS_MEM_ADDR
/*__heap_start是在链接脚本中定义的符号，
表示内存池的起始地址。
因此，OS_SYS_MEM_ADDR的值就是内存池的起始地址的指针，
可以通过该宏来访问系统内存池。*/
#define OS_SYS_MEM_ADDR (&__heap_start)
#endif
@ -223,9 +255,11 @@ extern CHAR __init_array_end__;
* Starting address of dynload heap
*/
#if defined (LOSCFG_KERNEL_NX) && defined (LOSCFG_KERNEL_DYNLOAD)
#define LOS_DL_HEAP_SIZE (LOSCFG_KERNLE_DYN_HEAPSIZE * 0x100000)
#define LOS_DL_HEAP_BASE (SYS_MEM_END - LOS_DL_HEAP_SIZE)
//如果这两个宏都被定义了，那么将动态加载模块堆的大小定义为
#define LOS_DL_HEAP_SIZE (LOSCFG_KERNLE_DYN_HEAPSIZE * 0x100000)//(LOSCFG_KERNLE_DYN_HEAPSIZE * 0x100000)
#define LOS_DL_HEAP_BASE (SYS_MEM_END - LOS_DL_HEAP_SIZE)//SYS_MEM_END - LOS_DL_HEAP_SIZE，其中SYS_MEM_END表示系统内存池的结束地址
#else
//如果没有定义LOSCFG_KERNEL_NX和LOSCFG_KERNEL_DYNLOAD宏，则将动态加载模块堆的大小和起始地址都定义为0。
#define LOS_DL_HEAP_SIZE 0
#define LOS_DL_HEAP_BASE 0
#endif
@ -236,7 +270,7 @@ extern CHAR __init_array_end__;
*/
#ifndef OS_SYS_MEM_SIZE
#define OS_SYS_MEM_SIZE ((g_sys_mem_addr_end) - \
((LOS_DL_HEAP_SIZE + ((UINTPTR)&__heap_start) + (64 - 1)) & ~(64 - 1)))
((LOS_DL_HEAP_SIZE + ((UINTPTR)&__heap_start) + (64 - 1)) & ~(64 - 1)))//定义内存池的大小
#endif
/****************************** fw Interface configuration **************************/
@ -245,11 +279,12 @@ extern CHAR __init_array_end__;
* The core number is one in non-SMP architecture.
*/
#ifdef LOSCFG_KERNEL_SMP
//LOSCFG_KERNEL_CORE_NUM 将被设置为 LOSCFG_KERNEL_SMP_CORE_NUM 的值；否则，LOSCFG_KERNEL_CORE_NUM 将被设置为 1。
#define LOSCFG_KERNEL_CORE_NUM LOSCFG_KERNEL_SMP_CORE_NUM
#else
#define LOSCFG_KERNEL_CORE_NUM 1
#endif
//LOSCFG_KERNEL_CPU_MASK 被定义为用于表示 CPU 核心掩码的表达式。它使用了位运算，通过将 1 左移 LOSCFG_KERNEL_CORE_NUM 位，然后减去 1，来生成一个包含 LOSCFG_KERNEL_CORE_NUM 个 1 的二进制数。这个数字通常用于设置 CPU 亲和性，以确定线程可以运行在哪些 CPU 核心上。
#define LOSCFG_KERNEL_CPU_MASK ((1 << LOSCFG_KERNEL_CORE_NUM) - 1)
/****************************** trace module configuration **************************/
@ -259,6 +294,10 @@ extern CHAR __init_array_end__;
*/
#ifdef LOSCFG_KERNEL_TRACE
#ifdef LOSCFG_RECORDER_MODE_OFFLINE
/*LOSCFG_KERNEL_TRACE 被定义的情况下，该代码块会被编译。
如果同时定义了 LOSCFG_RECORDER_MODE_OFFLINE，
则 LOSTRACE_BUFFER_SIZE 会被设置为 LOSCFG_TRACE_BUFFER_SIZE 的值；
否则，LOSTRACE_BUFFER_SIZE 会被设置为 0。*/
#define LOS_TRACE_BUFFER_SIZE LOSCFG_TRACE_BUFFER_SIZE
#else
#define LOS_TRACE_BUFFER_SIZE 0
@ -277,39 +316,44 @@ extern CHAR __init_array_end__;
/**
* Version number
*/
#define _T(x) x
#define HW_LITEOS_SYSNAME "Huawei LiteOS"
#define HW_LITEOS_SEP " "
#define _V(v) _T(HW_LITEOS_SYSNAME)_T(HW_LITEOS_SEP)_T(v)
//这段代码是一组宏定义，用于定义操作系统的版本号和系统名称。
#define _T(x) x//宏定义将传入的参数 x 原样返回，用于在宏定义中表示字符串。
#define HW_LITEOS_SYSNAME "Huawei LiteOS"//宏定义为字符串 "Huawei LiteOS"，表示操作系统的名称。
#define HW_LITEOS_SEP " "//宏定义为字符串 " "，表示名称和版本号之间的分隔符。
#define _V(v) _T(HW_LITEOS_SYSNAME)_T(HW_LITEOS_SEP)_T(v)//宏定义通过将操作系统名称和版本号连接起来，生成一个完整的版本字符串。
#define HW_LITEOS_VERSION "V200R005C20B053"
#define HW_LITEOS_VER _V(HW_LITEOS_VERSION"-SMP")
#define HW_LITEOS_VERSION "V200R005C20B053"//宏定义为字符串 "V200R005C20B053"，表示操作系统的具体版本号。
#define HW_LITEOS_VER _V(HW_LITEOS_VERSION"-SMP")//宏定义使用了 _V 宏，将操作系统名称和版本号连接起来，形成类似 "Huawei LiteOS V200R005C20B053-SMP" 的完整版本号字符串。
/**
* The Version number of Public
*/
#define MAJ_V 5
#define MIN_V 1
#define REL_V 0
#define MAJ_V 5//宏定义为整数 5，表示操作系统的主要版本号。
#define MIN_V 1//宏定义为整数 1，表示操作系统的次要版本号。
#define REL_V 0//宏定义为整数 0，表示操作系统的发布版本号。
/**
* The release candidate version number
*/
#define EXTRA_V 0
//这些宏定义和函数声明用于管理操作系统的版本号，并提供了一种将版本号转换为字符串格式的机制。
#define EXTRA_V 0//宏定义为整数 0，表示操作系统的额外版本号或候选版本号。
#define VERSION_NUM(a, b, c) (((a) << 16) | ((b) << 8) | (c))
#define HW_LITEOS_OPEN_VERSION_NUM VERSION_NUM(MAJ_V, MIN_V, REL_V)
#define VERSION_NUM(a, b, c) (((a) << 16) | ((b) << 8) | (c))//宏定义将主版本号 a、次版本号 b 和发布版本号 c 组合成一个无符号整数，通过位运算实现。
#define HW_LITEOS_OPEN_VERSION_NUM VERSION_NUM(MAJ_V, MIN_V, REL_V)// 宏定义使用了 VERSION_NUM 宏，将主版本号、次版本号和发布版本号组成一个表示版本号的无符号整数。
#define STRINGIFY_1(x) #x
#define STRINGIFY(x) STRINGIFY_1(x)
#define STRINGIFY_1(x) #x//宏定义将参数 x 转换为字符串。
#define STRINGIFY(x) STRINGIFY_1(x)//宏定义调用 STRINGIFY_1 宏，将参数转换为字符串。
#define HW_LITEOS_OPEN_VERSION_STRING STRINGIFY(MAJ_V) "." STRINGIFY(MIN_V) "." STRINGIFY(REL_V)
#define HW_LITEOS_OPEN_VERSION_STRING STRINGIFY(MAJ_V) "." STRINGIFY(MIN_V) "." STRINGIFY(REL_V)//宏定义使用了 STRINGIFY 宏，将主版本号、次版本号和发布版本号转换为形如 "5.1.0" 的字符串格式。
#if (EXTRA_V != 0)
/*不等于 0，则 HW_LITEOS_KERNEL_VERSION_STRING 宏定义为带有候选版本号的版本字符串；
否则，它被定义为不带候选版本号的版本字符串。*/
#define HW_LITEOS_KERNEL_VERSION_STRING HW_LITEOS_OPEN_VERSION_STRING "-rc" STRINGIFY(EXTRA_V)
#else
#define HW_LITEOS_KERNEL_VERSION_STRING HW_LITEOS_OPEN_VERSION_STRING
#endif
//不等于 0，则 HW_LITEOS_KERNEL_VERSION_STRING 宏定义为带有候选版本号的版本字符串；否则，它被定义为不带候选版本号的版本字符串。
extern VOID OsStart(VOID);
extern UINT32 OsMain(VOID);
extern VOID *OsGetMainTask(VOID);

16
src/kernel/include/los_cppsupport.h
Unescape View File

@ -47,6 +47,8 @@ extern "C" {
* If LOS_CppSystemInit() is called in the first stage of scatter load,
* this flag should be passed as the third parameter.
*/
/*如果在散射加载的第一阶段调用 LOS_CppSystemInit（），
则此标志应作为第三个参数传递。*/
#define BEFORE_SCATTER 0
/**
@ -54,6 +56,8 @@ extern "C" {
* If LOS_CppSystemInit() is called in the second stage of scatter load,
* this flag should be passed as the third parameter.
*/
/*如果在散射加载的第二阶段调用 LOS_CppSystemInit（），
则此标志应作为第三个参数传递。*/
#define AFTER_SCATTER 1
/**
@ -61,6 +65,8 @@ extern "C" {
* If scatter load is disabled, this flag should be passed as the third
* parameter when LOS_CppSystemInit() is called.
*/
/*如果禁用了分散加载，则在调用 LOS_CppSystemInit（） 时，
应将此标志作为第三个参数传递。*/
#define NO_SCATTER 2
/**
@ -87,6 +93,16 @@ extern "C" {
* <ul><li>los_cppsupport.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V100R001C00
*/
//初始化操作系统C++运行环境的函数
/*具体来说，LOS_CppSystemInit函数的主要工作包括：
调用全局静态对象的构造函数：在C++中，
全局静态对象的构造函数需要在程序开始运行前被调用。
LOS_CppSystemInit函数会遍历全局静态对象列表，
并依次调用它们的构造函数。
执行其他C++运行时环境的初始化工作：
除了全局静态对象的构造函数之外，
还可能需要执行其他与C++运行时环境相关的初始化工作。
例如，可以初始化C++异常处理机制、动态内存分配器等。*/
extern INT32 LOS_CppSystemInit(UINTPTR initArrayStart, UINTPTR initArrayEnd, INT32 flag);
#ifdef __cplusplus

41
src/kernel/include/los_cpup.h
Unescape View File

@ -53,6 +53,9 @@ extern "C" {
*
* Solution: Decrease the maximum number of tasks.
*/
/*在 CPU调度器模块中发生了内存不足的错误，
并且具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x00）生成的。
这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/
#define LOS_ERRNO_CPUP_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x00)
/**
@ -63,6 +66,9 @@ extern "C" {
*
* Solution: Check whether the pointer to the input parameter is usable.
*/
/*在 CPU调度器模块中发生了空指针错误，
并且具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x01）生成的。
这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/
#define LOS_ERRNO_CPUP_TASK_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x01)
/**
@ -73,6 +79,9 @@ extern "C" {
*
* Solution: Check whether the CPU usage is initialized.
*/
/*在 CPU调度器模块中发生了未初始化的错误，
具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x02）生成的。
这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/
#define LOS_ERRNO_CPUP_NO_INIT LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x02)
/**
@ -83,6 +92,9 @@ extern "C" {
*
* Solution: Check whether the number of threads is applicable for the current operation.
*/
/*在 CPU调度器模块中发生了无效的最大数量错误，
具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x03）生成的。
这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/
#define LOS_ERRNO_CPUP_MAXNUM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x03)
/**
@ -93,6 +105,9 @@ extern "C" {
*
* Solution: Check whether the target thread is created.
*/
/*在 CPU调度器模块中发生了线程未创建的错误，
具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x04）生成的。
这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/
#define LOS_ERRNO_CPUP_THREAD_NO_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x04)
/**
@ -103,12 +118,22 @@ extern "C" {
*
* Solution: Check whether the target task ID is applicable for the current operation.
*/
/*在CPU调度器模块中发生了无效的任务ID错误，
具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x05）生成的。
这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/
#define LOS_ERRNO_CPUP_TSK_ID_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x05)
/**
* @ingroup los_cpup
* The structure of the CPU usage information of all tasks.
*/
/*用于描述CPU调度器的信息。
结构体包含两个成员变量：
usStatus：表示任务的状态，是一个 16 位的无符号整数。
uwUsage：表示所有任务的 CPU 使用率，是一个 32 位的无符号整数，单位为 permillage，即千分之一。
在操作系统中，CPU 调度器会负责管理系统中各个任务的执行。
CPUP_INFO_S 结构体则提供了一种方式，
可以帮助了解任务状态和系统 CPU 使用情况的信息。*/
typedef struct tagCpupInfo {
UINT16 usStatus; /**< The task status. */
UINT32 uwUsage; /**< CPU usage of all tasks. It is a permillage. And the value range is [0,1000]. */
@ -118,9 +143,13 @@ typedef struct tagCpupInfo {
* @ingroup los_cpup
* The time period which the CPU usage collects in.
*/
//用于表示 CPU 使用率的时间范围。
enum {
//表示显示最近 10 秒钟的 CPU 使用率，值为0。
CPUP_LAST_TEN_SECONDS = 0, /**< Display CPU usage in the last ten seconds, the value is 0. */
//表示显示最近 1 秒钟的 CPU 使用率，值为1。
CPUP_LAST_ONE_SECONDS = 1, /**< Display CPU usage in the last one second, the value is 1. */
//表示显示从系统启动到现在的 CPU 使用率，值为 0xffff。
CPUP_ALL_TIME = 0xffff /**< Display CPU usage from system startup to now, the value is 0xffff. */
};
@ -149,6 +178,7 @@ enum {
* @see LOS_HistoryTaskCpuUsage | LOS_AllCpuUsage
* @since Huawei LiteOS V100R001C00
*/
//获取历史系统CPU使用率。参数 mode 是用来指定获取 CPU 使用率的时间范围或者其他相关设置。
extern UINT32 LOS_HistorySysCpuUsage(UINT32 mode);
/**
@ -182,6 +212,9 @@ extern UINT32 LOS_HistorySysCpuUsage(UINT32 mode);
* @see LOS_HistorySysCpuUsage
* @since Huawei LiteOS V100R001C00
*/
/*用于获取历史任务的CPU使用率。
其中 taskId 参数表示任务的ID或标识符，
mode 参数可能表示获取CPU使用率的模式或配置选项。*/
extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskId, UINT32 mode);
/**
@ -224,6 +257,10 @@ extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskId, UINT32 mode);
* <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V100R001C00
*/
/*用于获取系统中所有CPU的使用率信息。
其中 maxNum 参数表示最大的CPU数量，cpupInfo 参数表示用于存储CPU使用率信息的结构体指针，
mode 参数可能表示获取CPU使用率的模式或配置选项，
flag 参数则可能表示其他的控制标志位。*/
extern UINT32 LOS_AllCpuUsage(UINT16 maxNum, CPUP_INFO_S *cpupInfo, UINT32 mode, UINT16 flag);
/**
@ -244,6 +281,10 @@ extern UINT32 LOS_AllCpuUsage(UINT16 maxNum, CPUP_INFO_S *cpupInfo, UINT32 mode,
* <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V100R001C00
*/
/*LOS_CpupReset 函数会遍历系统中所有任务和中断，
将它们的 CPU 使用率统计信息清零。
这样，在下一次任务或中断执行时，
操作系统就会重新开始记录它们的 CPU 使用率。*/
extern VOID LOS_CpupReset(VOID);
#ifdef __cplusplus

20
src/kernel/include/los_err.h
Unescape View File

@ -62,11 +62,12 @@ extern "C" {
* <ul><li>los_err.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V100R001C00
*/
typedef VOID (*LOS_ERRORHANDLE_FUNC)(CHAR *fileName,
UINT32 lineNo,
UINT32 errorNo,
UINT32 paraLen,
VOID *para);
//LOS_ERRORHANDLE_FUNC 是一个函数指针类型，它指向一个函数，该函数具有以下特征：
typedef VOID (*LOS_ERRORHANDLE_FUNC)(CHAR *fileName,//表示发生错误的文件名。
UINT32 lineNo,//表示发生错误的行号。
UINT32 errorNo,//表示错误代码或错误号。
UINT32 paraLen,//表示附加参数的长度。
VOID *para);//表示附加参数的指针。
/**
* @ingroup los_err
@ -88,6 +89,15 @@ typedef VOID (*LOS_ERRORHANDLE_FUNC)(CHAR *fileName,
* <ul><li>los_err.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V100R001C00
*/
/*函数的作用是处理错误。当程序运行过程中发生错误时，
可以调用这个函数来进行错误处理，包括记录错误信息、输出错误日志等操作。
传入的参数可以用于定位和描述错误的具体信息，
从而更好地进行错误分析和排查。
CHAR *fileName：表示发生错误的文件名。
UINT32 lineNo：表示发生错误的行号。
UINT32 errorNo：表示错误码或错误类型。
UINT32 paraLen：表示传递的参数长度。
VOID *para：表示传递的参数。*/
extern UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo,
UINT32 errorNo, UINT32 paraLen,
VOID *para);

52
src/kernel/include/los_errno.h
Unescape View File

@ -46,31 +46,31 @@ extern "C" {
* @ingroup los_errno
* OS error code flag. It is a 24-bit unsigned integer. Its value is 0x000000U.
*/
#define LOS_ERRNO_OS_ID (0x00U << 16)
#define LOS_ERRNO_OS_ID (0x00U << 16)//宏定义为 0x00U << 16，表示操作系统相关的错误码。
/**
* @ingroup los_errno
* Define the error level as informative. It is a 32-bit unsigned integer. Its value is 0x00000000U.
*/
#define LOS_ERRTYPE_NORMAL (0x00U << 24)
#define LOS_ERRTYPE_NORMAL (0x00U << 24)//宏定义表示错误级别为 "informative"（信息级别），其值为 0x00U << 24。
/**
* @ingroup los_errno
* Define the error level as warning. It is a 32-bit unsigned integer. Its value is 0x01000000U.
*/
#define LOS_ERRTYPE_WARN (0x01U << 24)
#define LOS_ERRTYPE_WARN (0x01U << 24)//宏定义表示错误级别为 "warning"（警告级别），其值为 0x01U << 24。
/**
* @ingroup los_errno
* Define the error level as critical. It is a 32-bit unsigned integer. Its value is 0x02000000U.
*/
#define LOS_ERRTYPE_ERROR (0x02U << 24)
#define LOS_ERRTYPE_ERROR (0x02U << 24)//宏定义表示错误级别为 "critical"（严重级别），其值为 0x02U << 24。
/**
* @ingroup los_errno
* Define the error level as fatal. It is a 32-bit unsigned integer. Its value is 0x03000000U.
*/
#define LOS_ERRTYPE_FATAL (0x03U << 24)
#define LOS_ERRTYPE_FATAL (0x03U << 24)//宏定义表示错误级别为 "fatal"（致命级别），其值为 0x03U << 24。
/**
* @ingroup los_errno
@ -82,6 +82,14 @@ extern "C" {
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul>
*/
/*用于生成操作系统致命错误码。
LOS_ERRTYPE_FATAL 表示错误级别为 "fatal"（致命级别），其值为 0x03U << 24。
LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。
(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。
(UINT32)(ERRNO) 表示具体的错误码。
将上述宏和位运算组合起来，LOS_ERRNO_OS_FATAL 宏可以生成一个操作系统致命错误码，
其格式为：错误级别（LOS_ERRTYPE_FATAL）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。
通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。*/
#define LOS_ERRNO_OS_FATAL(MID, ERRNO) \
(LOS_ERRTYPE_FATAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
@ -95,6 +103,15 @@ extern "C" {
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul>
*/
/*这段代码定义了一个宏 LOS_ERRNO_OS_ERROR，用于生成操作系统严重错误码。
该宏使用了以下几个宏和位运算操作：
LOS_ERRTYPE_ERROR 表示错误级别为 "critical"（严重级别），其值为 0x02U << 24。
LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。
(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。
(UINT32)(ERRNO) 表示具体的错误码。
将上述宏和位运算组合起来，LOS_ERRNO_OS_ERROR 宏可以生成一个操作系统严重错误码，
其格式为：错误级别（LOS_ERRTYPE_ERROR）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。
通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。*/
#define LOS_ERRNO_OS_ERROR(MID, ERRNO) \
(LOS_ERRTYPE_ERROR | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
@ -108,6 +125,15 @@ extern "C" {
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul>
*/
/*这段代码定义了一个宏 LOS_ERRNO_OS_WARN，用于生成操作系统警告错误码。
该宏使用了以下几个宏和位运算操作：
LOS_ERRTYPE_WARN 表示错误级别为 "warning"（警告级别），其值为 0x01U << 24。
LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。
(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。
(UINT32)(ERRNO) 表示具体的错误码。
将上述宏和位运算组合起来，LOS_ERRNO_OS_WARN 宏可以生成一个操作系统警告错误码，
其格式为：错误级别（LOS_ERRTYPE_WARN）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。
通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。在发生警告级别的错误时，可以采取相应的处理措施以避免潜在问题的发生。*/
#define LOS_ERRNO_OS_WARN(MID, ERRNO) \
(LOS_ERRTYPE_WARN | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
@ -121,13 +147,29 @@ extern "C" {
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul>
*/
/*这段代码定义了一个宏 LOS_ERRNO_OS_NORMAL，用于生成操作系统普通错误码。
该宏使用了以下几个宏和位运算操作：
LOS_ERRTYPE_NORMAL 表示错误级别为 "normal"（普通级别），其值为 0x00U << 24。
LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。
(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。
(UINT32)(ERRNO) 表示具体的错误码。
将上述宏和位运算组合起来，LOS_ERRNO_OS_NORMAL 宏可以生成一个操作系统普通错误码，
其格式为：错误级别（LOS_ERRTYPE_NORMAL）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。
通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。在发生普通级别的错误时，可以根据需要进行相应的处理或记录。*/
#define LOS_ERRNO_OS_NORMAL(MID, ERRNO) \
(LOS_ERRTYPE_NORMAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
/**
* @ingroup los_errno
* Define the ID of each module in kernel. The ID is used in error code.
* 在内核中定义每个模块的 ID。该 ID 用于错误代码。
*/
/*这段代码定义了一个枚举类型 LOS_MODULE_ID，它包含了一系列的模块标识符及其对应的数值。
每个模块都有一个唯一的标识符，用于在代码中进行识别和引用。这些标识符的值是以十六进制表示的，比如 LOS_MOD_SYS 的值是 0x0，LOS_MOD_MEM 的值是 0x1，以此类推。
在这个枚举类型中，最后一个标识符 LOS_MOD_BUTT 是一个结束标志，表示枚举的结束。
通过使用这个枚举类型，你可以方便地使用这些模块标识符来表示、操作和传递不同的模块。
例如，你可以使用 LOS_MOD_SYS 来表示系统模块，在代码中进行相关的操作或者判断。
总之，这个枚举类型提供了一种简单而有序的方式来管理和使用各个模块的标识符。*/
enum LOS_MOUDLE_ID {
LOS_MOD_SYS = 0x0, /**< System ID. Its value is 0x0. */
LOS_MOD_MEM = 0x1, /**< Dynamic memory module ID. Its value is 0x1. */

162
src/kernel/include/los_event.h
Unescape View File

@ -47,19 +47,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
@ -69,6 +69,14 @@ extern "C" {
* Value: 0x02001c00.
*
* Solution: Set bits excluding bit 25 of the event mask to events.
* 这段代码定义了一个错误码 LOS_ERRNO_EVENT_SETBIT_INVALID，
表示事件设置位无效。在这个宏定义中使用了 LOS_ERRNO_OS_ERROR 宏，
该宏通常用于定义操作系统相关的错误码。
在这里，LOS_MOD_EVENT 表示错误码所属的模块是事件模块，
0x00 是该错误码在事件模块内部的具体编号。
通过使用这样的宏定义，可以方便地在代码中引用和传播错误码，
同时也有助于对错误进行分类和定位。当某个操作导致事件设置位无效时，
可以返回这个错误码，从而让调用者知道发生了什么问题并进行相应的处理。
*/
#define LOS_ERRNO_EVENT_SETBIT_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x00)
@ -81,6 +89,13 @@ extern "C" {
* Solution: Increase the waiting time for event reading, or make another task write a
* mask for the event.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_TIMEOUT，表示事件读取超时。同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x01。
当某个任务等待事件时，如果设定了超时时间，
并且在该时间内没有等到事件发生，那么就会返回这个错误码，
告知调用者事件读取超时。
这个错误码的定义可以帮助开发人员更好地判断和处理超时情况，
从而提高系统的稳定性和可靠性。*/
#define LOS_ERRNO_EVENT_READ_TIMEOUT LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x01)
/**
@ -92,6 +107,13 @@ extern "C" {
*
* Solution: Pass in a valid EVENTMASK value.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_EVENTMASK_INVALID，表示事件掩码无效。
同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，
表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x02。
事件掩码用于标识期望等待的事件，如果事件掩码无效，
则表示指定的事件掩码不符合规范或不可识别。当发生这种情况时，
可以返回这个错误码，告知调用者事件掩码无效。通过这个错误码的定义，
开发人员可以更好地检测和处理事件掩码相关的错误，从而提高系统的健壮性和可维护性。*/
#define LOS_ERRNO_EVENT_EVENTMASK_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x02)
/**
@ -102,6 +124,15 @@ extern "C" {
*
* Solution: Read the event in a task.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_IN_INTERRUPT，表示在中断中进行事件读取。
同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，
表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x03。
通常情况下，事件读取操作应该在任务上下文中进行，而不是在中断处理程序中执行。
因为中断处理程序具有高优先级，可能会引起任务调度的竞争和冲突。
当事件读取操作发生在中断上下文中时，就会返回这个错误码，
告知调用者在中断中进行了事件读取，这是不被支持的。
通过这个错误码的定义，可以帮助开发人员及时发现并修复在中断上下文中执行事件读取的问题，
确保系统的正确运行和可靠性。*/
#define LOS_ERRNO_EVENT_READ_IN_INTERRUPT LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x03)
/**
@ -115,6 +146,15 @@ extern "C" {
*
* Solution: Pass in a valid flag value.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_FLAGS_INVALID，表示事件标志无效。
同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，
表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x04。
事件标志用于标识特定的事件或状态，在进行事件操作时需要使用有效的事件标志。
当事件标志无效时，可能是因为传递了错误的标志参数或者标志参数不符合预期。
当发生这种情况时，可以返回这个错误码，告知调用者事件标志无效。
通过这个错误码的定义，可以帮助开发人员更好地检测和处理事件标志相关的错误，
从而提高系统的稳定性和可维护性。开发人员可以根据错误码来定位并修复导致事件标志无效的问题，
确保事件操作的准确性和可靠性。*/
#define LOS_ERRNO_EVENT_FLAGS_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x04)
/**
@ -125,6 +165,15 @@ extern "C" {
*
* Solution: Unlock the task and read the event.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_IN_LOCK，表示在锁定状态下进行事件读取。
同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，
表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x05。
通常情况下，事件读取操作应该在非锁定状态下进行，
因为在锁定状态下进行事件读取可能导致资源竞争和死锁等问题。
当发生在锁定状态下进行事件读取的情况时，可以返回这个错误码，
告知调用者事件读取发生在不合适的锁定状态下。
通过这个错误码的定义，开发人员可以及时发现并修复在锁定状态下执行事件读取的问题，
确保系统的正确运行和可靠性。这有助于提高系统的并发性和避免潜在的问题。*/
#define LOS_ERRNO_EVENT_READ_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x05)
/**
@ -135,6 +184,14 @@ extern "C" {
*
* Solution: Check whether the input parameter is null.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_PTR_NULL，表示传入的指针为空指针。
同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，
表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x06。
在进行事件操作时，通常需要传递一些参数，如事件掩码、事件标志、事件句柄等。
如果传递的指针为空指针，可能会导致访问非法内存、程序崩溃等问题。当发生这种情况时，
可以返回这个错误码，告知调用者传入的指针为空指针。
通过这个错误码的定义，开发人员可以及时发现并修复传入空指针的问题，
确保系统的正确运行和可靠性。这有助于提高系统的稳定性和可维护性。*/
#define LOS_ERRNO_EVENT_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x06)
/**
@ -147,6 +204,15 @@ extern "C" {
* Solution: Read the event in a vailid task.
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_IN_SYSTEM_TASK，
表示在系统任务中进行了事件读取操作。同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，
表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x07。
一般来说，系统任务具有较高的特权级别，并且用于操作系统内部的关键任务，
而不是用于普通的应用程序任务。因此，在系统任务中进行事件读取可能会引起不可预期的行为，
破坏系统的稳定性和可靠性。当发生在系统任务中进行事件读取的情况时，
可以返回这个错误码，告知调用者不应该在系统任务中执行事件读取操作。
通过这个错误码的定义，可以帮助开发人员避免在系统任务中执行事件读取操作，
从而确保系统的正常运行和安全性。这有助于提高系统的稳定性和可维护性。*/
#define LOS_ERRNO_EVENT_READ_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x07)
/**
@ -157,12 +223,29 @@ extern "C" {
*
* Solution: Check whether the event list is not empty.
*/
/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_SHOULD_NOT_DESTORY，
表示试图销毁不应该被销毁的事件。同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，
表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x08。
在事件处理过程中，有些事件可能不应该被销毁，因为它们可能仍在被其他任务或线程使用。
如果试图销毁这些事件，可能会导致错误的行为，如资源泄漏、程序崩溃等问题。当发生这种情况时，可以返回这个错误码，告知调用者不应该销毁这些事件。
通过这个错误码的定义，可以帮助开发人员避免销毁不应该被销毁的事件，
从而确保系统的正常运行和可靠性。这有助于提高系统的稳定性和可维护性。*/
#define LOS_ERRNO_EVENT_SHOULD_NOT_DESTORY LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x08)
/**
* @ingroup los_event
* Event control structure
*/
/*这段代码定义了一个名为 tagEvent 的结构体，其中包含两个成员变量：
uwEventID：表示事件掩码，在事件控制块中指示已经逻辑处理的事件。
通常用于标识事件的类型或属性。
stEventList：是一个链表节点，用于将事件控制块进行链接，以支持对事件的管理操作。
此外，通过 typedef 关键字将 struct tagEvent 重新定义为 EVENT_CB_S 类型，
同时定义了指向 EVENT_CB_S 结构体的指针类型 PEVENT_CB_S。
这种结构体的设计通常用于事件管理模块，用于存储和管理事件相关的信息，
包括事件的标识和事件控制块的链表关系。
开发人员可以使用这样的结构体来实现事件的创建、删除、等待和触发等功能，
从而更好地管理系统中的异步事件，提高系统的并发处理能力。*/
typedef struct tagEvent {
UINT32 uwEventID; /**< Event mask in the event control block,
indicating the event that has been logically processed. */
@ -187,6 +270,15 @@ typedef struct tagEvent {
* @see LOS_EventClear
* @since Huawei LiteOS V100R001C00
*/
/*UINT32 LOS_EventInit(PEVENT_CB_S eventCB) 是 LiteOS 操作系统中的一个函数，
用于初始化事件控制块。
参数 eventCB 是指向事件控制块结构体 EVENT_CB_S 的指针，
该结构体用于存储和管理事件相关的信息。
函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。
通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误，则返回对应的错误码。
调用 LOS_EventInit 函数可以在使用事件之前对事件控制块进行初始化。
通过此函数，可以确保事件控制块的初始状态正确，
并且可以安全地使用事件控制块进行事件的等待、触发和处理等操作。*/
extern UINT32 LOS_EventInit(PEVENT_CB_S eventCB);
/**
@ -223,6 +315,25 @@ extern UINT32 LOS_EventInit(PEVENT_CB_S eventCB);
* @see LOS_EventRead | LOS_EventWrite
* @since Huawei LiteOS V100R001C00
*/
/*UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode) 是 LiteOS 操作系统中的一个函数，用于轮询事件。
参数说明:
eventId 是一个指向无符号整数的指针，用于存储轮询到的事件ID。
eventMask 是一个无符号整数，表示希望轮询的事件掩码。
mode 是一个无符号整数，表示轮询模式，可以是以下几种值之一：
OS_EVENT_OR：轮询任意一个在事件掩码中设置的事件。
OS_EVENT_AND：轮询所有在事件掩码中设置的事件。
函数的返回值 UINT32 是一个无符号整数，
表示函数执行的结果或错误码。通常，如果函数成功执行，则返回 LOS_OK 表示成功；
如果发生错误，则返回对应的错误码。
调用 LOS_EventPoll 函数可以轮询指定的事件，并根据指定的模式检查事件是否已经触发。
如果有事件符合条件，
函数会将事件ID写入 eventId 指向的地址，并返回 LOS_OK；如果没有事件符合条件，
函数会根据轮询模式返回相应的错误码（如 LOS_ERRNO_EVENT_UNAVAILABLE）。
此函数通常与其他事件管理函数配合使用，用于实现任务的等待和事件驱动的机制。
通过轮询事件，任务可以根据不同的事件状态来决定后续的操作，
实现异步事件处理和任务调度的功能。*/
extern UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode);
/**
@ -263,6 +374,24 @@ extern UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode);
* @see LOS_EventPoll | LOS_EventWrite
* @since Huawei LiteOS V100R001C00
*/
/*UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout)
是 LiteOS 操作系统中的一个函数，用于读取事件。
参数说明:
eventCB 是一个指向事件控制块结构体 EVENT_CB_S 的指针，表示要读取的事件控制块。
eventMask 是一个无符号整数，表示希望读取的事件掩码。
mode 是一个无符号整数，表示读取模式，可以是以下几种值之一：
OS_EVENT_OR：等待任意一个在事件掩码中设置的事件。
OS_EVENT_AND：等待所有在事件掩码中设置的事件。
timeout 是一个无符号整数，表示超时时间，单位为系统时钟节拍数。
如果超过指定时间仍未满足读取条件，则函数返回超时错误码。
函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。
通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误或超时，则返回对应的错误码。
调用 LOS_EventRead 函数可以等待指定的事件触发，并根据指定的模式检查事件是否已经触发。
如果有事件符合条件，函数会返回 LOS_OK；如果没有事件符合条件，
函数会根据读取模式等待事件的触发，直到满足条件或超时。在等待期间，任务可能会被挂起，
直到事件满足读取条件。
此函数通常与其他事件管理函数配合使用，用于实现任务的等待和事件驱动的机制。通过读取事件，
任务可以根据不同的事件状态来决定后续的操作，实现异步事件处理和任务调度的功能。*/
extern UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout);
/**
@ -311,6 +440,17 @@ extern UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events);
* @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite
* @since Huawei LiteOS V100R001C00
*/
/*UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events) 是 LiteOS 操作系统中的一个函数，用于写入事件。
参数说明:
eventCB 是一个指向事件控制块结构体 EVENT_CB_S 的指针，表示要写入事件的事件控制块。
events 是一个无符号整数，表示要写入的事件掩码。
函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。
通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误，则返回对应的错误码。
调用 LOS_EventWrite 函数可以向指定的事件控制块写入事件。
事件掩码表示一个或多个事件的状态，通过将相应的事件位设置为 1 来表示事件已经触发。
当事件写入后，等待该事件的任务可能会被唤醒，根据事件的状态来决定后续的操作。
此函数通常与其他事件管理函数配合使用，用于实现任务之间的同步与通信。
通过写入事件，任务可以触发其他任务的执行，实现任务的协调与同步的功能。*/
extern UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events);
/**
@ -333,6 +473,22 @@ extern UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events);
* @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite
* @since Huawei LiteOS V100R001C00
*/
/*UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB) 是 LiteOS 操作系统中的一个函数，用于销毁事件控制块。
参数说明:
eventCB 是一个指向事件控制块结构体 EVENT_CB_S 的指针，表示要销毁的事件控制块。
函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。
通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误，则返回对应的错误码。
调用 LOS_EventDestroy 函数可以销毁一个事件控制块，释放该事件控制块所占用的资源。
一旦事件控制块被销毁，将不能再使用该事件控制块进行事件管理操作。
在实际应用中，当不再需要某个事件控制块时，
可以通过调用 LOS_EventDestroy 函数来释放相关资源，防止资源泄漏和系统资源浪费。
需要注意的是，在销毁事件控制块之前，
需要确保没有任务正在等待该事件或者使用该事件进行同步操作，
否则可能会导致系统行为异常。*/
extern UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB);
#ifdef __cplusplus

75
src/kernel/include/los_exc.h
Unescape View File

@ -61,6 +61,23 @@ extern "C" {
* los_exc.h: the header file that contains the API declaration.
* @since Huawei LiteOS V100R001C00
*/
/*LOS_Panic(const CHAR *fmt, ...) 是 LiteOS 操作系统中的一个函数，用于触发系统崩溃。
参数说明:
fmt 是一个格式化字符串，表示崩溃信息的格式。
... 是可变参数列表，根据格式化字符串 fmt 的要求，传入相应的参数。
该函数没有返回值。
调用 LOS_Panic 函数会导致系统进入崩溃状态，即系统无法正常继续执行下去。
通常情况下，该函数用于处理严重错误或不可恢复的异常情况，
以防止系统继续执行可能导致更严重问题的代码。
该函数允许通过格式化字符串传递一些额外的信息，
从而提供关于崩溃原因、位置或其他相关信息的描述。这
些信息可能对于调试和排查问题非常有用。
需要注意的是，LOS_Panic 函数应该谨慎使用，仅在必要时使用。
由于该函数触发系统崩溃，会导致系统停止运行并且无法继续恢复，
因此应该避免在正常的业务逻辑中调用该函数，以免造成不必要的系统中断。*/
VOID LOS_Panic(const CHAR *fmt, ...);
/**
@ -79,8 +96,22 @@ VOID LOS_Panic(const CHAR *fmt, ...);
* los_exc.h: the header file that contains the API declaration.
* @since Huawei LiteOS V200R005C10
*/
/*VOID LOS_BackTrace(VOID) 是 LiteOS 操作系统中的函数，用于获取当前线程的函数调用栈信息。
该函数没有参数，也没有返回值。
调用 LOS_BackTrace 函数会获取当前线程的函数调用栈信息，
包括每个函数的调用地址以及相应的函数名。这些信息对于调试和排查问题非常有用，
可以帮助开发人员了解程序执行时的函数调用流程，定位问题所在。
通常情况下，LOS_BackTrace 函数用于调试目的，在程序出现异常或错误时，
可以通过打印函数调用栈信息来辅助分析问题原因。
这对于定位崩溃、死锁或其他异常情况非常有帮助。
需要注意的是，LOS_BackTrace 函数的实现可能依赖于具体的硬件平台和编译器，
不同的平台和编译器可能会有不同的实现方式和限制。
因此，在使用该函数时需要了解相关的平台和编译器特性，以确保获取到准确的函数调用栈信息。*/
extern VOID LOS_BackTrace(VOID);
#define OsBackTrace LOS_BackTrace
//宏定义将 OsBackTrace 替换为 LOS_BackTrace，意味着在代码中使用 OsBackTrace 时，实际上是调用 LOS_BackTrace 函数。
/**
* @ingroup los_exc
@ -99,9 +130,28 @@ extern VOID LOS_BackTrace(VOID);
* los_exc.h: the header file that contains the API declaration.
* @since Huawei LiteOS V100R001C00
*/
/*VOID LOS_TaskBackTrace(UINT32 taskID) 是 LiteOS 操作系统中的函数，用于获取指定任务的函数调用栈信息。
参数说明:
taskID 是一个无符号整数，表示要获取函数调用栈信息的目标任务的任务ID。
该函数没有返回值。
调用 LOS_TaskBackTrace 函数可以获取指定任务的函数调用栈信息，
包括每个函数的调用地址以及相应的函数名。这些信息对于调试和排查问题非常有用，
可以帮助开发人员了解指定任务执行时的函数调用流程，定位问题所在。
通常情况下，LOS_TaskBackTrace 函数用于调试目的，在特定任务出现异常或错误时，
可以通过打印该任务的函数调用栈信息来辅助分析问题原因。
这对于定位崩溃、死锁或其他异常情况非常有帮助。
需要注意的是，LOS_TaskBackTrace 函数的实现可能依赖于具体的硬件平台和编译器，
不同的平台和编译器可能会有不同的实现方式和限制。
因此，在使用该函数时需要了解相关的平台和编译器特性，以确保获取到准确的函数调用栈信息。
另外，需要确保指定的任务ID是有效的、存在的任务ID，
否则可能导致获取不到正确的函数调用栈信息。*/
extern VOID LOS_TaskBackTrace(UINT32 taskID);
#define OsTaskBackTrace LOS_TaskBackTrace
//宏定义将 OsTaskBackTrace 替换为 LOS_TaskBackTrace，意味着在代码中使用 OsTaskBackTrace 时，实际上是调用 LOS_TaskBackTrace 函数。
#ifdef LOSCFG_SHELL_EXCINFO_DUMP
/**
* @ingroup los_exc
@ -122,7 +172,14 @@ extern VOID LOS_TaskBackTrace(UINT32 taskID);
* <ul><li>los_exc.h: the header file that contains the type definition.</li></ul>
* @since Huawei LiteOS V200R005C10
*/
/*这是一个函数指针类型的定义。它定义了一个名为 LogReadWriteFunc 的函数指针类型，
该函数指针指向一个返回类型为 VOID 的函数，
函数参数为 UINTPTR startAddr、UINT32 space、UINT32 rwFlag 和 CHAR *buf。
这种定义方式可以用来声明符合特定函数签名的函数指针类型，以便在代码中使用。*/
typedef VOID (*LogReadWriteFunc)(UINTPTR startAddr, UINT32 space, UINT32 rwFlag, CHAR *buf);
/*这是一个宏定义，将 log_read_write_fn 替换为 LogReadWriteFunc。
注释中指出这是一个旧的API，并建议避免使用它。通过这个宏定义，
可以将 log_read_write_fn 在整个代码中替换为 LogReadWriteFunc，以达到简化和统一的目的。*/
#define log_read_write_fn LogReadWriteFunc /* old API since V200R002C00, please avoid use of it */
/**
@ -146,6 +203,22 @@ typedef VOID (*LogReadWriteFunc)(UINTPTR startAddr, UINT32 space, UINT32 rwFlag,
* <ul><li>los_exc.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V200R002C00
*/
/*函数 LOS_ExcInfoRegHook 是在 LiteOS 操作系统中的一个函数。它的作用是设置异常信息寄存器的回调钩子函数。
该函数有四个参数：
startAddr：异常信息寄存器的起始地址。
space：异常信息寄存器的大小（以字节为单位）。
buf：用于存储异常信息寄存器内容的缓冲区。
hook：回调钩子函数，类型为 LogReadWriteFunc，即函数指针类型。
具体来说，当发生异常时，LiteOS 将会调用 LOS_ExcInfoRegHook 函数，
并将异常信息寄存器的起始地址、大小和缓冲区作为参数传递给它。
然后，在 LOS_ExcInfoRegHook 函数内部，
可以通过回调钩子函数 hook 来处理异常信息寄存器的内容。
这个功能可以用于自定义异常处理和异常信息记录。通过设置回调钩子函数，
可以在异常发生时获取并处理异常信息寄存器的内容，
以便进行进一步的分析或记录。*/
VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 space, CHAR *buf, LogReadWriteFunc hook);
#endif

3
src/kernel/include/los_hw.h
Unescape View File

@ -59,9 +59,10 @@ extern "C" {
* los_hw.h: the header file that contains the API declaration.
* @since Huawei LiteOS V200R003C00
*/
/*这段代码定义了一个静态内联函数 LOS_CpuInfo，该函数返回一个指向常量字符的指针。*/
STATIC INLINE const CHAR *LOS_CpuInfo(VOID)
{
return ArchCpuInfo();
return ArchCpuInfo();//函数会根据当前的硬件平台调用对应的底层函数，以获取关于CPU的信息，例如型号、频率、核心数等等。这个函数的实现通常是与硬件平台紧密相关的，并且可能需要一些底层的寄存器读取或其他特定平台相关的操作。
}
#ifdef __cplusplus

353
src/kernel/include/los_hwi.h
Unescape View File

@ -48,12 +48,16 @@ extern "C" {
* @ingroup los_hwi
* Count of interrupts.
*/
/*这行代码声明了一个名为g_intCount的数组，但它的定义并不在当前的源文件中。
关键字"extern"告诉编译器该数组是在其他地方定义的，这通常意味着它在其他源文件或库中。
在链接阶段，编译器会去找到实际的g_intCount的定义，然后将其与当前的代码进行链接。*/
extern size_t g_intCount[];
/**
* An interrupt is active.
*/
extern size_t IntActive(VOID);
extern size_t IntActive(VOID);//IntActive(VOID)函数是用于获取当前活动的中断数量的函数。该函数没有参数，返回类型为无符号整数类型（size_t）。
/**
* @ingroup los_hwi
@ -61,6 +65,16 @@ extern size_t IntActive(VOID);
*
* @see OS_INT_INACTIVE
*/
/*在LiteOS操作系统中，#define OS_INT_ACTIVE IntActive() 是一个预处理指令，用来定义一个宏。它将OS_INT_ACTIVE 定义为调用 IntActive() 函数的结果。
宏定义是一种在代码中使用的文本替换机制。在这种情况下，
当代码中出现 OS_INT_ACTIVE 时，预处理器会将其替换为 IntActive() 函数的调用，从
而实际上就是将函数调用作为一个宏使用。
这种宏定义的目的可能是为了简化代码书写或提高代码的可读性。
通过定义宏，可以通过简单的名称（OS_INT_ACTIVE）来表示复杂的函数调用（IntActive()），
从而使代码更加简洁和易于理解。*/
#define OS_INT_ACTIVE IntActive()
/**
@ -71,6 +85,21 @@ extern size_t IntActive(VOID);
*
* @see OS_INT_ACTIVE
*/
/*在LiteOS操作系统中，#define OS_INT_INACTIVE (!(OS_INT_ACTIVE)) 是一个预处理指令，
用来定义一个宏。它将OS_INT_INACTIVE 定义为对 OS_INT_ACTIVE 取反的结果。
具体来说，OS_INT_ACTIVE 是一个宏，表示调用 IntActive() 函数的结果。
而 OS_INT_INACTIVE 是另一个宏，表示对 OS_INT_ACTIVE 取反的结果。
在这种情况下，使用逻辑非运算符 ! 将 OS_INT_ACTIVE 的结果取反。
这个宏定义的目的可能是用于表示当前中断是否处于非活动状态。
如果 OS_INT_ACTIVE 为真（非零），则表示中断处于活动状态；
而 OS_INT_INACTIVE 则为假（零），表示中断处于非活动状态。
通过这种方式定义宏，可以方便地在代码中判断中断状态并进行相应的处理。
代码中使用 OS_INT_INACTIVE 可以更加直观地表示中断是否处于非活动状态，
提高代码的可读性和可维护性。
*/
#define OS_INT_INACTIVE (!(OS_INT_ACTIVE))
/**
@ -78,6 +107,18 @@ extern size_t IntActive(VOID);
* Highest priority of a hardware interrupt.This is an external parameter.
* The priority range is [OS_HWI_PRIO_HIGHEST, OS_HWI_PRIO_HIGHEST + LOSCFG_HWI_PRIO_LIMIT - 1].
*/
/*在LiteOS操作系统中，#define OS_HWI_PRIO_HIGHEST 0 是一个预处理指令，
用来定义一个宏。它将 OS_HWI_PRIO_HIGHEST 定义为数字 0。
在LiteOS操作系统中，中断（Interrupt）也被称为硬件中断（Hardware Interrupt），
简称为 HWI。HWI具有不同的优先级（Priority），优先级越高，中断响应的时间越短。
OS_HWI_PRIO_HIGHEST 是一个表示最高中断优先级的宏，其值为 0。
在LiteOS操作系统中，中断的优先级是用数字表示的，数字越小表示优先级越高。
因此，OS_HWI_PRIO_HIGHEST 表示的是最高中断优先级，也就是数字最小的中断优先级。
在一些特定场景下，需要使用最高中断优先级，
这时候可以使用 OS_HWI_PRIO_HIGHEST 宏来表示最高中断优先级的数字值 0，
从而方便地进行代码编写。*/
#define OS_HWI_PRIO_HIGHEST 0
/**
@ -85,12 +126,36 @@ extern size_t IntActive(VOID);
* This represents the interrupt priority range, the larger number, the lower priority, the interrupt processor is
* modified uniformly.
*/
/*在LiteOS操作系统中，
#define OS_HWI_PRIO_LOWEST (LOSCFG_HWI_PRIO_LIMIT - 1) 是一个预处理指令，
用来定义一个宏。它将 OS_HWI_PRIO_LOWEST 定义为 LOSCFG_HWI_PRIO_LIMIT 减去 1 的结果。
在LiteOS操作系统中，中断（Interrupt）也被称为硬件中断（Hardware Interrupt），
简称为 HWI。HWI具有不同的优先级（Priority），优先级越高，中断响应的时间越短。OS_HWI_PRIO_LOWEST 是一个表示最低中断优先级的宏，其值为 LOSCFG_HWI_PRIO_LIMIT - 1。
LOSCFG_HWI_PRIO_LIMIT 是一个配置参数，用于表示系统支持的最大中断优先级数。
因此，OS_HWI_PRIO_LOWEST 表示的是最低中断优先级，也就是数字最大的中断优先级，
其值等于最大中断优先级数减去 1。
在一些特定场景下，需要使用最低中断优先级，
这时候可以使用 OS_HWI_PRIO_LOWEST 宏来表示最低中断优先级的数字值，从而方便地进行代码编写。*/
#define OS_HWI_PRIO_LOWEST (LOSCFG_HWI_PRIO_LIMIT - 1)
/**
* @ingroup los_hwi
* The lower priority number, the higher priority, so OS_HWI_PRIO_LOWEST big than OS_HWI_PRIO_HIGHEST.
*/
/*该宏接受一个参数 pri，表示要判断的中断优先级值。
宏的定义使用了逻辑与运算符 && 和比较运算符 >=、<=。
具体解释如下：
((pri) >= OS_HWI_PRIO_HIGHEST) 表示判断 pri 是否大于等于最高中断优先级（OS_HWI_PRIO_HIGHEST）。如果 pri 大于等于最高中断优先级，则该条件结果为真（非零）；否则为假（零）。
((pri) <= OS_HWI_PRIO_LOWEST) 表示判断 pri 是否小于等于最低中断优先级（OS_HWI_PRIO_LOWEST）。如果 pri 小于等于最低中断优先级，则该条件结果为真（非零）；否则为假（零）。
整个宏定义将以上两个条件使用逻辑与运算符 && 连接起来，
即 (((pri) >= OS_HWI_PRIO_HIGHEST) && ((pri) <= OS_HWI_PRIO_LOWEST))。
只有当 pri 同时满足大于等于最高中断优先级和小于等于最低中断优先级时，
该条件结果为真（非零），表示中断优先级有效；否则为假（零），表示中断优先级无效。
这个宏的作用是在进行中断优先级的判断和设置时，
确保所使用的中断优先级值在有效范围内，避免出现错误的中断优先级设置。*/
#define HWI_PRI_VALID(pri) (((pri) >= OS_HWI_PRIO_HIGHEST) && ((pri) <= OS_HWI_PRIO_LOWEST))
/**
@ -105,6 +170,23 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用来定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_NUM_INVALID 是一个表示无效中断号的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，
它接受两个参数：模块号和错误码值。
其中，LOS_MOD_HWI 表示HWI模块的模块号，0x00 表示错误码值。
因此，LOS_ERRNO_HWI_NUM_INVALID 的值就是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_NUM_INVALID 是 LOS_ERRNO_HWI_NUM_INVALID 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示无效中断号的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在配置和使用中断时，如果遇到了无效的中断号，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_NUM_INVALID 或 OS_ERRNO_HWI_NUM_INVALID，
来判断中断号是否有效，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_NUM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x00)
#define OS_ERRNO_HWI_NUM_INVALID LOS_ERRNO_HWI_NUM_INVALID
@ -120,6 +202,22 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用来定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_PROC_FUNC_NULL 是一个表示中断处理函数为空的错误码。该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，
它接受两个参数：模块号和错误码值。
其中，LOS_MOD_HWI 表示HWI模块的模块号，0x01 表示错误码值。
因此，LOS_ERRNO_HWI_PROC_FUNC_NULL 的值就是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_PROC_FUNC_NULL 是 LOS_ERRNO_HWI_PROC_FUNC_NULL 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断处理函数为空的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在配置和使用中断时，如果中断处理函数为空，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_PROC_FUNC_NULL 或 OS_ERRNO_HWI_PROC_FUNC_NULL，来判断中断处理函数是否正确设置，
进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_PROC_FUNC_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x01)
#define OS_ERRNO_HWI_PROC_FUNC_NULL LOS_ERRNO_HWI_PROC_FUNC_NULL
@ -132,6 +230,18 @@ extern size_t IntActive(VOID);
* Solution: This error code is not in use temporarily.
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
/**/
/*定义了一个错误码，表示硬件中断（HWI）回调函数不可用的情况。
具体解释如下：
OS_ERRNO_HWI_CB_UNAVAILABLE 是用来表示硬件中断（HWI）回调函数不可用的错误码。
它由 LOS_ERRNO_OS_ERROR 宏生成，该宏接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x02 表示错误码值。
因此，OS_ERRNO_HWI_CB_UNAVAILABLE 的值是根据模块号和错误码值计算得出的。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置和注册中断回调函数时，如果回调函数不可用，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_CB_UNAVAILABLE，来判断回调函数的可用性，
从而进行相应的错误处理。*/
#define OS_ERRNO_HWI_CB_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x02)
/**
@ -146,6 +256,21 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用来定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_NO_MEMORY 是一个表示无法分配内存的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
其中，LOS_MOD_HWI 表示HWI模块的模块号，0x03 表示错误码值。
因此，LOS_ERRNO_HWI_NO_MEMORY 的值就是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_NO_MEMORY 是 LOS_ERRNO_HWI_NO_MEMORY 的别名。通过将其定义为相同的值，
可以在代码中使用更简洁的名称来表示无法分配内存的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置和注册中断处理函数时，如果出现无法分配内存的情况，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_NO_MEMORY 或 OS_ERRNO_HWI_NO_MEMORY，
来判断内存是否分配成功，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x03)
#define OS_ERRNO_HWI_NO_MEMORY LOS_ERRNO_HWI_NO_MEMORY
@ -162,6 +287,22 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用于定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_ALREADY_CREATED 是一个表示中断已经被创建的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x04 表示错误码值。
因此，LOS_ERRNO_HWI_ALREADY_CREATED 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_ALREADY_CREATED 是 LOS_ERRNO_HWI_ALREADY_CREATED 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断已经被创建的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在创建中断时，如果中断已经被创建，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_ALREADY_CREATED 或 OS_ERRNO_HWI_ALREADY_CREATED，
来判断中断是否已经存在，从而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_ALREADY_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x04)
#define OS_ERRNO_HWI_ALREADY_CREATED LOS_ERRNO_HWI_ALREADY_CREATED
@ -177,6 +318,22 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用于定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_PRIO_INVALID 是一个表示中断优先级无效的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x05 表示错误码值。
因此，LOS_ERRNO_HWI_PRIO_INVALID 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_PRIO_INVALID 是 LOS_ERRNO_HWI_PRIO_INVALID 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断优先级无效的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置中断优先级时，如果提供了无效的优先级值，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_PRIO_INVALID 或 OS_ERRNO_HWI_PRIO_INVALID，来判断优先级是否有效，
进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_PRIO_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x05)
#define OS_ERRNO_HWI_PRIO_INVALID LOS_ERRNO_HWI_PRIO_INVALID
@ -189,6 +346,18 @@ extern size_t IntActive(VOID);
* Solution: This error code is not in use temporarily.
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
/*是一个预处理指令，用于定义错误码。
该错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，
具体来说是中断模式无效的错误。
它是通过使用LiteOS提供的错误码宏 LOS_ERRNO_OS_ERROR 来定义的。
该宏接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x06 表示错误码值。
因此，OS_ERRNO_HWI_MODE_INVALID 的值是根据模块号和错误码值计算得出的。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置中断模式时，如果提供了无效的模式值，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_MODE_INVALID ，
来判断模式是否有效，进而进行相应的错误处理。*/
#define OS_ERRNO_HWI_MODE_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x06)
/**
@ -200,6 +369,19 @@ extern size_t IntActive(VOID);
* Solution: This error code is not in use temporarily.
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
/*是一个预处理指令，用于定义错误码。
该错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，
具体来说是快速中断模式已经被创建的错误。
它是通过使用LiteOS提供的错误码宏 LOS_ERRNO_OS_ERROR 来定义的。
该宏接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x07 表示错误码值。
因此，OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED 的值是根据模块号和错误码值计算得出的。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在创建快速中断模式时，如果该模式已经被创建，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED ，
来判断快速中断模式是否已经存在，从而进行相应的错误处理。*/
#define OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x07)
/**
@ -214,6 +396,23 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用于定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断发生错误的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_INTERR 是一个表示硬件中断发生错误的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，
它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x08 表示错误码值。
因此，LOS_ERRNO_HWI_INTERR 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_INTERR 是 LOS_ERRNO_HWI_INTERR 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示硬件中断发生错误的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在中断处理函数中，如果硬件中断发生错误，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_INTERR 或 OS_ERRNO_HWI_INTERR，
来判断中断是否发生了错误，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x08)
#define OS_ERRNO_HWI_INTERR LOS_ERRNO_HWI_INTERR
@ -230,6 +429,22 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用于定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是共享中断错误的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_SHARED_ERROR 是一个表示共享中断错误的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x09 表示错误码值。
因此，LOS_ERRNO_HWI_SHARED_ERROR 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_SHARED_ERROR 是 LOS_ERRNO_HWI_SHARED_ERROR 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示共享中断错误的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置共享中断时，如果发生了错误，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_SHARED_ERROR 或 OS_ERRNO_HWI_SHARED_ERROR，
来判断共享中断是否设置成功，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_SHARED_ERROR LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x09)
#define OS_ERRNO_HWI_SHARED_ERROR LOS_ERRNO_HWI_SHARED_ERROR
@ -242,6 +457,20 @@ extern size_t IntActive(VOID);
* Solution: This error code is not in use temporarily.
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
/*是一个预处理指令，用于定义错误码。
这个错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断参数无效的错误。
它是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
OS_ERRNO_HWI_ARG_INVALID 是一个表示硬件中断参数无效的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x0a 表示错误码值。
因此，OS_ERRNO_HWI_ARG_INVALID 的值是根据模块号和错误码值计算得出的。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在注册硬件中断处理函数时，如果传递给函数的参数无效，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_ARG_INVALID，来判断参数是否有效，
进而进行相应的错误处理。*/
#define OS_ERRNO_HWI_ARG_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x0a)
/**
@ -257,6 +486,22 @@ extern size_t IntActive(VOID);
* <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
* </ul>
*/
/*是两个预处理指令，用于定义错误码。
这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断号未创建的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：
LOS_ERRNO_HWI_HWINUM_UNCREATE 是一个表示硬件中断号未创建的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x0b 表示错误码值。
因此，LOS_ERRNO_HWI_HWINUM_UNCREATE 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_HWINUM_UNCREATE 是 LOS_ERRNO_HWI_HWINUM_UNCREATE 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示硬件中断号未创建的错误码。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在请求处理某个硬件中断时，如果指定的中断号未创建，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_HWINUM_UNCREATE 或 OS_ERRNO_HWI_HWINUM_UNCREATE，
来判断中断号是否有效，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_HWINUM_UNCREATE LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x0b)
#define OS_ERRNO_HWI_HWINUM_UNCREATE LOS_ERRNO_HWI_HWINUM_UNCREATE
@ -264,18 +509,21 @@ extern size_t IntActive(VOID);
* @ingroup los_hwi
* Define the type HWI_HANDLE_T for a hardware interrupt number, the type is an unsigned int.
*/
//这行代码定义了一个新的类型 HWI_HANDLE_T，它被定义为 UINT32，即无符号32位整数。在这里，HWI_HANDLE_T 被用来表示硬件中断的句柄或标识符。
typedef UINT32 HWI_HANDLE_T;
/**
* @ingroup los_hwi
* Define the type HWI_PRIOR_T for a hardware interrupt priority, the type is an unsigned short.
*/
//这行代码定义了一个新的类型 HWI_PRIOR_T，它被定义为 UINT16，即无符号16位整数。在这里，HWI_PRIOR_T 被用来表示硬件中断的优先级。
typedef UINT16 HWI_PRIOR_T;
/**
* @ingroup los_hwi
* Define the type HWI_MODE_T for hardware interrupt mode configurations, the type is an unsigned short.
*/
//这行代码定义了一个新的类型 HWI_MODE_T，它被定义为 UINT16，即无符号16位整数。在这里，HWI_MODE_T 被用来表示硬件中断的模式配置。
typedef UINT16 HWI_MODE_T;
/**
@ -283,6 +531,9 @@ typedef UINT16 HWI_MODE_T;
* Define the type HWI_ARG_T for the parameter used for the hardware interrupt creation function.
* The function of this parameter varies among platforms.
*/
/*这行代码定义了一个新的类型 HWI_ARG_T，它被定义为 UINTPTR，
即一个无符号整数，其大小与指针大小相同。
在这里，HWI_ARG_T 被用来表示硬件中断创建函数的参数，其具体含义会因平台而异。*/
typedef UINTPTR HWI_ARG_T;
/**
@ -303,6 +554,8 @@ typedef UINTPTR HWI_ARG_T;
* @see LOS_HwiCreate
* @since Huawei LiteOS V100R001C00
*/
/*这行代码定义了一个函数指针类型 HWI_PROC_FUNC，它指向一个没有参数和返回值的函数。
在这里，HWI_PROC_FUNC 被用来表示硬件中断处理函数的类型。*/
typedef VOID (*HWI_PROC_FUNC)(VOID);
/**
@ -311,12 +564,22 @@ typedef VOID (*HWI_PROC_FUNC)(VOID);
*
* The flag only used by the kernel as part of the IRQ handling routines.
*/
/*这个宏定义了一个常量 IRQF_SHARED，其值为 0x8000U。
在这里，IRQF_SHARED 用于表示一个共享的硬件中断。*/
#define IRQF_SHARED 0x8000U
/**
* @ingroup los_hwi
* The hardware interrupt parameter for #LOS_HwiDelete and interrupt handler in #LOS_HwiCreate.
*/
/*这个代码定义了一个名为 HWI_IRQ_PARAM_S 的结构体类型，结构体内包含了以下成员：
int swIrq: 表示中断号的整数变量。
VOID *pDevId: 表示触发中断的设备ID的指针变量。
const CHAR *pName: 表示中断名称的指针变量。
这个结构体类型 HWI_IRQ_PARAM_S 用作 LOS_HwiDelete 函数和 LOS_HwiCreate 函数中的硬件中断参数。
通过使用这个结构体，
可以传递中断号、设备ID和中断名称等信息给函数，以进行相应的操作或处理。*/
typedef struct tagIrqParam {
int swIrq; /**< The interrupt number */
VOID *pDevId; /**< The pointer to the device ID that launches the interrupt */
@ -340,6 +603,27 @@ typedef struct tagIrqParam {
* @see LOS_IntRestore
* @since Huawei LiteOS V100R001C00
*/
/*这段代码定义了一个静态内联函数 LOS_IntLock()，具体解释如下：
STATIC INLINE：
STATIC 关键字指示该函数的作用域为当前文件，在其他文件中不可见。
INLINE 关键字告诉编译器将该函数的代码插入到调用处，而不是生成函数调用。
UINT32：
UINT32 表示返回值类型为无符号32位整数。
LOS_IntLock(VOID)：
LOS_IntLock 是函数的名称，它接受一个 VOID 参数，表示没有输入参数。
return ArchIntLock();：
这行代码调用了 ArchIntLock() 函数，并将其返回值作为 LOS_IntLock() 函数的返回值。
ArchIntLock() 是一个硬件相关的函数，用于禁用中断，并返回之前的中断状态。
因为函数声明为内联函数且函数体非常简单，
所以编译器会在调用处直接插入 ArchIntLock() 的代码，提高执行效率。
总结：LOS_IntLock() 函数是一个内联函数，
它调用底层的 ArchIntLock() 函数来禁用中断，并返回之前的中断状态。
这个函数的目的是为了保护关键代码区域，防止被中断打断，以确保数据的一致性和可靠性。*/
STATIC INLINE UINT32 LOS_IntLock(VOID)
{
return ArchIntLock();
@ -361,6 +645,13 @@ STATIC INLINE UINT32 LOS_IntLock(VOID)
* <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
* @see LOS_IntLock
*/
/*return ArchIntUnlock();：
这行代码调用了 ArchIntUnlock() 函数，并将其返回值作为 LOS_IntUnLock() 函数的返回值。
ArchIntUnlock() 是一个硬件相关的函数，用于恢复之前被禁用的中断状态。
总结：LOS_IntUnLock() 函数是一个内联函数，
它调用底层的 ArchIntUnlock() 函数来恢复之前被禁用的中断状态。
这个函数的目的是为了在临界区执行完毕后，恢复中断，允许其他中断事件发生。*/
STATIC INLINE UINT32 LOS_IntUnLock(VOID)
{
return ArchIntUnlock();
@ -384,6 +675,14 @@ STATIC INLINE UINT32 LOS_IntUnLock(VOID)
* @see LOS_IntLock
* @since Huawei LiteOS V100R001C00
*/
/*ArchIntRestore(intSave);：
这行代码调用了 ArchIntRestore() 函数，将之前保存的中断状态作为参数传递给它。
ArchIntRestore() 是一个硬件相关的函数，用于根据传入的中断状态值恢复中断。
总结：LOS_IntRestore() 函数是一个内联函数，
它调用底层的 ArchIntRestore() 函数来根据之前保存的中断状态恢复中断。
这个函数的目的是在一段被禁用中断的代码执行完毕后，恢复中断状态，允许其他中断事件发生。
由于函数没有返回值，所以不会返回任何结果。*/
STATIC INLINE VOID LOS_IntRestore(UINT32 intSave)
{
ArchIntRestore(intSave);
@ -430,11 +729,11 @@ STATIC INLINE VOID LOS_IntRestore(UINT32 intSave)
* @see LOS_HwiDelete
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,
HWI_PRIOR_T hwiPrio,
HWI_MODE_T hwiMode,
HWI_PROC_FUNC hwiHandler,
HWI_IRQ_PARAM_S *irqParam);
extern UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,//表示中断号或中断向量的标识。
HWI_PRIOR_T hwiPrio,//表示中断的优先级。
HWI_MODE_T hwiMode,//表示中断的模式（如边沿触发、电平触发等）。
HWI_PROC_FUNC hwiHandler,//表示中断处理函数的指针。
HWI_IRQ_PARAM_S *irqParam);//表示中断参数的结构体指针。
/**
* @ingroup los_hwi
@ -470,6 +769,9 @@ extern UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,
* @see LOS_HwiCreate
* @since Huawei LiteOS V100R001C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中删除一个中断处理程序。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要删除的中断号或中断向量的标识。
HWI_IRQ_PARAM_S *irqParam 是函数的第二个参数，表示中断参数的结构体指针。*/
extern UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam);
/**
@ -492,6 +794,8 @@ extern UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam);
* <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V200R005C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中触发一个指定的中断。
//HWI_HANDLE_T hwiNum 是函数的参数，表示要触发的中断号或中断向量的标识。
extern UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum);
/**
@ -513,6 +817,10 @@ extern UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum);
* <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V200R005C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中清除（复位）一个指定的中断。
/*HWI_HANDLE_T hwiNum 是函数的参数，表示要清除的中断号或中断向量的标识。
函数的作用是根据指定的中断号，将相应的中断标志位清除，即将中断状态复位。
通过调用该函数，可以清除中断触发后的状态，以便重新准备下一次中断处理。*/
extern UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum);
/**
@ -536,6 +844,10 @@ extern UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum);
* @see LOS_HwiDisable
* @since Huawei LiteOS V200R005C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中使能（启用）一个指定的中断。
/*HWI_HANDLE_T hwiNum 是函数的参数，表示要使能的中断号或中断向量的标识。
函数的作用是根据指定的中断号，将相应的中断使能位设置为有效，即启用该中断。
启用中断后，当满足中断触发条件时，系统将会跳转执行对应的中断处理程序。*/
extern UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum);
/**
@ -558,6 +870,10 @@ extern UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum);
* @see LOS_HwiEnable
* @since Huawei LiteOS V200R005C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中禁用（关闭）一个指定的中断。
/*HWI_HANDLE_T hwiNum 是函数的参数，表示要禁用的中断号或中断向量的标识。
函数的作用是根据指定的中断号，将相应的中断使能位设置为无效，即禁用该中断。
禁用中断后，即使满足中断触发条件，系统也不会跳转执行对应的中断处理程序。*/
extern UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum);
#ifdef LOSCFG_KERNEL_SMP
@ -582,6 +898,11 @@ extern UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum);
* <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V200R005C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中向指定的处理器发送中断请求。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要发送的中断号或中断向量的标识。
UINT32 cpuMask 是函数的第二个参数，表示中断发送的目标处理器掩码，用于指定将中断发送到哪些处理器上。
函数的作用是向指定的处理器发送中断请求，
即通过中断控制器向目标处理器发送中断信号，触发相应的中断处理操作。*/
extern UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask);
/**
@ -605,6 +926,12 @@ extern UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask);
* <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V200R005C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中设置指定中断的亲和性（Affinity）。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要设置亲和性的中断号或中断向量的标识。
UINT32 cpuMask 是函数的第二个参数，表示要设置的中断亲和性掩码，用于指定该中断可以在哪些处理器上执行。
函数的作用是设置指定中断的亲和性，即将中断与特定的处理器相关联。当中断被触发时，
只有与中断亲和性相关的处理器才会尝试执行中断处理程序，
从而避免了不必要的中断传递和处理开销。*/
extern UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask);
#endif /* LOSCFG_KERNEL_SMP */
@ -632,6 +959,11 @@ extern UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask);
* @see None
* @since Huawei LiteOS V200R005C00
*/
//是一个函数声明，用于在 LiteOS 操作系统中设置指定中断的优先级（Priority）。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要设置优先级的中断号或中断向量的标识。
HWI_PRIOR_T priority 是函数的第二个参数，表示要设置的中断优先级。
函数的作用是设置指定中断的优先级，即确定中断在系统中的相对执行优先级。
较高优先级的中断将优先获得处理器资源，并在其他中断之前得到响应和执行。*/
extern UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority);
#ifdef LOSCFG_KERNEL_LOWPOWER
@ -652,6 +984,10 @@ extern UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority);
* @see None.
* @since Huawei LiteOS V200R005C10
*/
//是一个函数指针类型的定义。
/*这部分定义了函数指针所指向的函数的参数列表，其中包含一个名为 hwiNum 的参数，其类型为 HWI_HANDLE_T。
因此，整体来说，typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum) 定义了一个函数指针类型 WAKEUPFROMINTHOOK，
它指向一个不返回数值的函数，并且该函数接受一个 HWI_HANDLE_T 类型的参数 hwiNum。*/
typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum);
/**
@ -671,6 +1007,11 @@ typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum);
* @see None.
* @since Huawei LiteOS V200R005C10
*/
//是用于注册中断唤醒钩子函数的外部声明。
/*WAKEUPFROMINTHOOK hook 是函数的参数，它是一个指向中断唤醒钩子函数的指针。
函数的作用是注册中断唤醒钩子函数，
即将指定的函数指针（指向中断唤醒处理函数的指针）注册到系统中，
以便在特定的中断事件发生时执行相应的处理操作。*/
extern VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook);
#endif

Write Preview
Loading…
Cancel
Save