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

Merge pull request '王维轮合并' (#15) from wangweilun_branch into master

Browse Source
master
p2gpamesw 10 months ago
parent 4656ae1926 18da38ac08
commit c9d89c67b4
17 changed files with 602 additions and 292 deletions
Show Stats Download Patch File Download Diff File

BIN
doc/王维轮泛读报告.docx
View File

Binary file not shown.

37
src/kernel/base/sched/sched_mq/los_sched.c
Unescape View File

@ -58,7 +58,7 @@ typedef struct {
LOS_DL_LIST queues[NPQS]; /* one for each priority */
SPIN_LOCK_S lock; /* private spinlock */
} PriQueue;
/*用于实现一个具有多个优先级的队列结构，并提供了相关的数据结构和锁来支持队列操作的线程安全性*/
/* priority queue per-cpu */
STATIC PriQueue g_priqueue[LOSCFG_KERNEL_CORE_NUM];
@ -68,17 +68,20 @@ STATIC INLINE UINT32 OsMpIdleMask(VOID)
{
return ((~g_activeCpu) & LOSCFG_KERNEL_CPU_MASK);
}
/*这个函数可能用来计算当前处于空闲状态的 CPU 核心的掩码。STATIC 关键字表示该函数是静态的，只在当前文件内可见，
而 INLINE 关键字通常用于建议编译器内联该函数以提高执行效率。*/
STATIC INLINE VOID OsMpSetIdle(UINT32 cpu)
{
g_activeCpu &= ~CPUID_TO_AFFI_MASK(cpu);
}
/*这个函数可能用于将指定的 CPU 核心设置为待机状态。
它通过将对应的位掩码从 g_activeCpu 中清除，以实现将核心置为非活动状态。*/
STATIC INLINE VOID OsMpSetActive(UINT32 cpu)
{
g_activeCpu |= CPUID_TO_AFFI_MASK(cpu);
}
/*这个函数可能用于将指定的 CPU 核心设置为活动状态。
它通过将对应的位掩码加入到 g_activeCpu 中，以实现将核心置为活动状态*/
VOID OsPriQueueInit(VOID)
{
LOS_DL_LIST *priQueues = NULL;
@ -97,7 +100,7 @@ VOID OsPriQueueInit(VOID)
}
}
}
/*这段代码的作用是初始化多核系统中每个核心的优先级队列，确保每个队列都处于初始状态*/
UINT32 OsPriQueueSize(UINT32 priority)
{
UINT32 itemCnt = 0;
@ -112,7 +115,7 @@ UINT32 OsPriQueueSize(UINT32 priority)
return itemCnt;
}
/*这段代码的作用是获取多核系统中某个核心指定优先级的队列中的任务数量*/
UINT32 OsPriQueueTotalSize(VOID)
{
UINT32 priority;
@ -125,7 +128,7 @@ UINT32 OsPriQueueTotalSize(VOID)
return totalSize;
}
/*这段代码的作用是计算多核系统中所有优先级队列的总任务数量，以便进行系统性能监控和优化*/
UINT32 OsSchedPickCpu(LosTaskCB* task)
{
UINT32 cpuid, lastMask, cpuidMask, affinity;
@ -158,7 +161,7 @@ UINT32 OsSchedPickCpu(LosTaskCB* task)
return cpuid;
}
/*这段代码的作用是根据任务的亲和性、空闲核心和任务上次运行的核心等信息，选择一个适合调度任务的 CPU 核心。*/
VOID OsPriQueueAdd(PriQueue *priQueue, LosTaskCB* task, QueueOps flag)
{
LOS_DL_LIST *priQueues = NULL;
@ -179,7 +182,7 @@ VOID OsPriQueueAdd(PriQueue *priQueue, LosTaskCB* task, QueueOps flag)
LOS_ListTailInsert(&priQueues[priority], &task->pendList);
}
}
/*这段代码的作用是根据任务的优先级，将任务插入到对应优先级的队列中，并更新相应的位图信息。*/
/*
* Insert a task to the head of priority queue, only available
* when putting running task back to the ready queue.
@ -189,14 +192,14 @@ VOID OsPriQueueEnqueueHead(LOS_DL_LIST *queueNode, UINT32 priority)
LosTaskCB *task = LOS_DL_LIST_ENTRY(queueNode, LosTaskCB, pendList);
OsPriQueueAdd(&g_priqueue[ArchCurrCpuid()], task, QUEUE_HEAD);
}
/*这段代码的作用是将指定任务插入到指定优先级队列的队头，用于在将当前任务从运行态切换到就绪态时，将当前任务重新插入到相应优先级队列的队头*/
VOID OsPriQueueEnqueueTail(LOS_DL_LIST *queueNode, UINT32 priority)
{
LosTaskCB *task = LOS_DL_LIST_ENTRY(queueNode, LosTaskCB, pendList);
OsPriQueueAdd(&g_priqueue[ArchCurrCpuid()], task, QUEUE_TAIL);
}
/*这段代码的作用是将指定任务插入到指定优先级队列的队尾，用于在将一个新的任务从就绪态加入到相应优先级队列时，将任务插入到队尾*/
/*
* Insert a task to the tail of priority queue. The pri-queue might be
* this or another core's.
@ -215,7 +218,7 @@ VOID OsPriQueueEnqueue(LOS_DL_LIST *queueNode, UINT32 priority)
/* add the task to the cpu per-core pri-queue */
OsPriQueueAdd(&g_priqueue[cpuid], task, QUEUE_TAIL);
}
/*这段代码的作用是将指定任务加入到相应的优先级队列中，并根据任务的调度要求选择适当的 CPU*/
VOID OsPriQueueDequeue(LOS_DL_LIST *queueNode)
{
LosTaskCB *task = NULL;
@ -234,7 +237,7 @@ VOID OsPriQueueDequeue(LOS_DL_LIST *queueNode)
(*bitmap) &= ~(PRI0_BIT >> task->priority);
}
}
/*这段代码的作用是从优先级队列中删除指定的任务节点，并在必要时更新位图以反映每个优先级队列的状态*/
LITE_OS_SEC_TEXT_MINOR LosTaskCB *OsGetTopTask(VOID)
{
LosTaskCB *newTask = NULL;
@ -262,7 +265,7 @@ LITE_OS_SEC_TEXT_MINOR LosTaskCB *OsGetTopTask(VOID)
out:
return newTask;
}
/*这段代码的作用是从当前 CPU 的优先级队列中获取具有最高优先级的任务，并将其从队列中删除。*/
VOID OsSchedResched(VOID)
{
LosTaskCB *runTask = NULL;
@ -326,7 +329,7 @@ VOID OsSchedResched(VOID)
/* do the task context switch */
OsTaskSchedule(newTask, runTask);
}
/*这段代码实现了两个任务之间的上下文切换，包括状态更新、占用时间计算、任务监控等一系列处理，并最终调用 OsTaskSchedule 函数切换到新的任务执行。*/
VOID OsSchedPreempt(VOID)
{
LosTaskCB *runTask = NULL;
@ -357,7 +360,7 @@ VOID OsSchedPreempt(VOID)
SCHEDULER_UNLOCK(intSave);
}
/*这段代码实现了抢占式调度的功能，能够在高优先级任务到来时立即暂停正在运行的低优先级任务，提高系统的响应速度和稳定性*/
#ifdef LOSCFG_BASE_CORE_TIMESLICE
LITE_OS_SEC_TEXT VOID OsTimesliceCheck(VOID)
{
@ -370,7 +373,7 @@ LITE_OS_SEC_TEXT VOID OsTimesliceCheck(VOID)
}
}
#endif
/*这段代码实现了基于时间片的轮转调度算法，通过限制每个任务的执行时间，实现了任务之间的公平调度*/
#ifdef __cplusplus
#if __cplusplus
}

14
src/kernel/base/sched/sched_sq/los_priqueue.c
Unescape View File

@ -60,7 +60,7 @@ UINT32 OsPriQueueInit(VOID)
return LOS_OK;
}
/*这段代码是用于初始化优先级队列的函数 OsPriQueueInit*/
VOID OsPriQueueEnqueueHead(LOS_DL_LIST *priqueueItem, UINT32 priority)
{
/*
@ -76,7 +76,7 @@ VOID OsPriQueueEnqueueHead(LOS_DL_LIST *priqueueItem, UINT32 priority)
LOS_ListHeadInsert(&g_priQueueList[priority], priqueueItem);
}
/*这段代码是用于将一个节点插入到优先级队列头部的函数*/
VOID OsPriQueueEnqueue(LOS_DL_LIST *priqueueItem, UINT32 priority)
{
/*
@ -92,7 +92,7 @@ VOID OsPriQueueEnqueue(LOS_DL_LIST *priqueueItem, UINT32 priority)
LOS_ListTailInsert(&g_priQueueList[priority], priqueueItem);
}
/*这段代码是用于将一个节点插入到优先级队列尾部的函数*/
VOID OsPriQueueDequeue(LOS_DL_LIST *priqueueItem)
{
LosTaskCB *runTask = NULL;
@ -103,7 +103,7 @@ VOID OsPriQueueDequeue(LOS_DL_LIST *priqueueItem)
g_priQueueBitmap &= ~(PRIQUEUE_PRIOR0_BIT >> runTask->priority);
}
}
/*这个函数的作用是取出优先级队列中的队首节点，并更新相应的状态信息。*/
LOS_DL_LIST *OsPriQueueTop(VOID)
{
UINT32 priority;
@ -115,7 +115,7 @@ LOS_DL_LIST *OsPriQueueTop(VOID)
return NULL;
}
/*这个函数的作用是获取当前优先级队列中的队首节点，并返回该节点的指针，以供后续操作使用*/
UINT32 OsPriQueueSize(UINT32 priority)
{
UINT32 itemCnt = 0;
@ -140,7 +140,7 @@ UINT32 OsPriQueueSize(UINT32 priority)
return itemCnt;
}
/*这个函数的作用是计算指定优先级队列中节点的数量，可以用于监控任务在不同优先级队列中的排队情况*/
LITE_OS_SEC_TEXT_MINOR LosTaskCB *OsGetTopTask(VOID)
{
UINT32 priority;
@ -170,7 +170,7 @@ LITE_OS_SEC_TEXT_MINOR LosTaskCB *OsGetTopTask(VOID)
OUT:
return newTask;
}
/*这个函数的作用是获取优先级最高的任务控制块，并将其从相应的优先级队列中移除，以便进行调度执行*/
#ifdef __cplusplus
#if __cplusplus
}

6
src/kernel/base/sched/sched_sq/los_sched.c
Unescape View File

@ -103,7 +103,7 @@ VOID OsSchedResched(VOID)
/* do the task context switch */
OsTaskSchedule(newTask, runTask);
}
/*这段代码实现了操作系统的任务调度功能，根据任务的优先级和状态来选择合适的任务进行切换，并更新任务状态及相关信息，最终实现任务的切换和调度*/
VOID OsSchedPreempt(VOID)
{
LosTaskCB *runTask = NULL;
@ -134,7 +134,7 @@ VOID OsSchedPreempt(VOID)
SCHEDULER_UNLOCK(intSave);
}
/*这段代码实现了在需要进行任务抢占时，将当前任务标记为就绪状态并重新加入就绪队列，然后触发任务重新调度，以实现任务的抢占和切换。*/
#ifdef LOSCFG_BASE_CORE_TIMESLICE
LITE_OS_SEC_TEXT VOID OsTimesliceCheck(VOID)
{
@ -147,7 +147,7 @@ LITE_OS_SEC_TEXT VOID OsTimesliceCheck(VOID)
}
}
#endif
/*这段代码实现了时间片轮转调度算法中的时间片检查和调度触发功能，当任务时间片用尽时，会自动触发调度，让其他可运行任务有机会获得 CPU 时间片并进行执行。*/
#ifdef __cplusplus
#if __cplusplus
}

49
src/kernel/include/los_runstop.h
Unescape View File

@ -25,16 +25,16 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */
/*该函数定义提供了运行停止功能所需的接口和参数类型，为嵌入式系统中的运行停止操作提供了基本的支持
/**
* @defgroup los_runstop Wakeup
* @ingroup kernel
*/
#ifndef _LOS_RUNSTOP_H
#ifndef _LOS_RUNSTOP_H 组的定义：该组包含了一些与运行停止有关的函数和宏定义。
#define _LOS_RUNSTOP_H
#include "los_typedef.h"
#include "los_typedef.h"包含了 LOS Kernel 所需的基本类型定义。
#ifdef __cplusplus
#if __cplusplus
@ -43,7 +43,7 @@ extern "C" {
#endif /* __cplusplus */
/**
* @ingroup los_runstop
* @ingroup los_runstop ##该回调函数类型定义用于在唤醒阶段调用。它允许用户定义一个函数，当系统从休眠状态唤醒时，该函数将被调用
* @brief Define the type of a runstop callback function.
*
* @par Description:
@ -63,7 +63,7 @@ extern "C" {
* @see None.
* @since Huawei LiteOS V100R001C00
*/
typedef VOID (*RUNSTOP_CALLBACK_FUNC)(VOID);
typedef VOID (*RUNSTOP_CALLBACK_FUNC)(VOID);/*函数指针类型RUNSTOP_CALLBACK_FUNC，用于定义运行停止时的回调函数，没有参数和返回值
/**
* @ingroup los_runstop
@ -88,7 +88,10 @@ typedef VOID (*RUNSTOP_CALLBACK_FUNC)(VOID);
* @see None.
* @since Huawei LiteOS V100R001C00
*/
typedef INT32 (*FLASH_READ_FUNC)(VOID *memAddr, size_t start, size_t size);
typedef INT32 (*FLASH_READ_FUNC)(VOID *memAddr, size_t start, size_t size);/*定义了一个名为FLASH_READ_FUNC的函数指针类型，用于定义一个从Flash中读取数据的函数
memAddr：用于存储从Flash中读取数据的内存起始地址
start：从Flash中读取数据的起始地址
size：从Flash中读取的数据大小。
/**
* @ingroup los_runstop
@ -113,7 +116,10 @@ typedef INT32 (*FLASH_READ_FUNC)(VOID *memAddr, size_t start, size_t size);
* @see None.
* @since Huawei LiteOS V100R001C00
*/
typedef INT32 (*FLASH_WRITE_FUNC)(VOID *memAddr, size_t start, size_t size);
typedef INT32 (*FLASH_WRITE_FUNC)(VOID *memAddr, size_t start, size_t size);/*定义一个用于写入flash数据的函数类
memAddr：要从中读取数据并写入到某个flash的内存起始地址。
start：要写入数据的某个flash的起始地址。
size：要写入到某个flash的数据的大小
/**
* @ingroup los_runstop
@ -122,20 +128,17 @@ typedef INT32 (*FLASH_WRITE_FUNC)(VOID *memAddr, size_t start, size_t size);
* Information of specified parameters passed in during runstop.
*/
typedef struct tagRunstopParam {
RUNSTOP_CALLBACK_FUNC pfIdleWakeupCallback; /* < Wake up callback function, called in idle task */
RUNSTOP_CALLBACK_FUNC pfWakeupCallback; /* < Wake up callback function */
RUNSTOP_CALLBACK_FUNC pfImageDoneCallback; /* < Image done callback function, called just after memory is stored */
FLASH_READ_FUNC pfFlashReadFunc; /* < An abstract function for reading data from a certain flash */
FLASH_WRITE_FUNC pfFlashWriteFunc; /* < An abstract function for writing data to a certain flash */
size_t uwFlashReadAlignSize; /* < Block align size when reading data from a certain flash */
size_t uwFlashEraseAlignSize; /* < Block align size when erasing data in a certain flash */
size_t uwFlashWriteAlignSize; /* < Block align size when writing data to a certain flash */
UINTPTR uwWowFlashAddr; /* < The flash starting address to which the memory is to be
stored, the address should be flash write-alignment length
aligned */
UINTPTR uwImageFlashAddr; /* < The flash starting address where the whole application image
is burned */
} RUNSTOP_PARAM_S;
RUNSTOP_CALLBACK_FUNC pfIdleWakeupCallback; /*< 空闲任务中的唤醒回调函数 */
RUNSTOP_CALLBACK_FUNC pfWakeupCallback; /*< 唤醒回调函数 */
RUNSTOP_CALLBACK_FUNC pfImageDoneCallback; /*< 内存存储完成后的回调函数 */
FLASH_READ_FUNC pfFlashReadFunc; /*< 从某个闪存中读取数据的抽象函数 */
FLASH_WRITE_FUNC pfFlashWriteFunc; /*< 向某个闪存中写入数据的抽象函数 */
size_t uwFlashReadAlignSize; /*< 从某个闪存中读取数据时的块对齐大小 */
size_t uwFlashEraseAlignSize; /*< 擦除某个闪存中数据时的块对齐大小 */
size_t uwFlashWriteAlignSize; /*< 向某个闪存中写入数据时的块对齐大小 */
UINTPTR uwWowFlashAddr; /* < 存储内存的闪存起始地址，地址应与闪存写入对齐长度对齐 */
UINTPTR uwImageFlashAddr; /* < 整个应用程序镜像烧录到的闪存起始地址 */
} RUNSTOP_PARAM_S;/*是用于传递和配置运行停止功能所需的参数信息
/**
* @ingroup los_runstop
@ -159,8 +162,8 @@ typedef struct tagRunstopParam {
* @see
* @since Huawei LiteOS V100R001C00
*/
extern VOID LOS_MakeImage(const RUNSTOP_PARAM_S *runstopParam);
extern VOID LOS_MakeImage(const RUNSTOP_PARAM_S *runstopParam);/*定义了一个名为LOS_MakeImage的函数，用于将内存映像存储到flash中。
函数接受一个名为runstopParam的参数，该参数包含了一些关键信息，用于runstop使用，包括要存储内存映像的flash起始地址等。
#ifdef __cplusplus
#if __cplusplus
}

87
src/kernel/include/los_sem.h
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.
* --------------------------------------------------------------------------- */
/*这段代码实现了对信号量操作的基本功能，包括创建、删除、请求和释放信号量，并对可能出现的错误情况进行了定义和说明。*/
/**
* @defgroup los_sem Semaphore
* @ingroup kernel
@ -49,17 +49,17 @@ extern "C" {
* @ingroup los_sem
* Max count of counting semaphores
*/
#define LOS_SEM_COUNT_MAX 0xFFFE
#define LOS_SEM_COUNT_MAX 0xFFFE/*计数信号量的最大值*/
/**
* @ingroup los_sem
* Semaphore error code: The memory is insufficient.
* @ingroup los_sem 该宏定义属于信号量模块。
* Semaphore error code: The memory is insufficient. 内存不足
*
* Value: 0x02000700.
* Value: 0x02000700. 以十六进制表示
*
* Solution: Allocate more memory.
* Solution: Allocate more memory. 解决该错误的方法为分配更多的内存。
*/
#define LOS_ERRNO_SEM_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x00)
#define LOS_ERRNO_SEM_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x00)/*定义一个信号量（Semaphore）的错误码，表示内存不足
/**
* @ingroup los_sem
@ -72,14 +72,15 @@ extern "C" {
#define LOS_ERRNO_SEM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x01)
/**
* @ingroup los_sem
* Semaphore error code: Null pointer.
* @ingroup los_sem 该宏定义属于信号量模块。
* Semaphore error code: Null pointer. 该错误码的含义为参数无效。
*
* Value: 0x02000702.
* Value: 0x02000702. 以十六进制表示
*
* Solution: Change the passed-in null pointer to a valid non-null pointer.
* Solution: Change the passed-in null pointer to a valid non-null pointer. 解决该错误的方法：将传入的无效参数值更改为有效值
*/
#define LOS_ERRNO_SEM_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x02)
#define LOS_ERRNO_SEM_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x02)/*这段代码定义了一个信号量模块的错误码，表示参数无效
/**
* @ingroup los_sem
@ -87,9 +88,9 @@ extern "C" {
*
* Value: 0x02000703.
*
* Solution: Perform corresponding operations based on the requirements in the code context.
* Solution: Perform corresponding operations based on the requirements in the code context.解决该错误的方法：根据代码上下文的要求执行相应的操作。
*/
#define LOS_ERRNO_SEM_ALL_BUSY LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x03)
#define LOS_ERRNO_SEM_ALL_BUSY LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x03)/*定义了一个信号量模块的错误码，表示没有可用的信号量控制结构*/
/**
* @ingroup los_sem
@ -97,9 +98,9 @@ extern "C" {
*
* Value: 0x02000704.
*
* Solution: Change the passed-in parameter value to a valid nonzero value.
* Solution: Change the passed-in parameter value to a valid nonzero value.解决该错误的方法：将传入的参数值更改为有效的非零值
*/
#define LOS_ERRNO_SEM_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x04)
#define LOS_ERRNO_SEM_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x04)/*定义了一个信号量模块的错误码，表示指定的超时时间参数无效*/
/**
* @ingroup los_sem
@ -107,9 +108,9 @@ extern "C" {
*
* Value: 0x02000705.
*
* Solution: Do not call the API during an interrupt.
* Solution: Do not call the API during an interrupt.解决该错误的方法a:不要在中断期间调用该API
*/
#define LOS_ERRNO_SEM_PEND_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x05)
#define LOS_ERRNO_SEM_PEND_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x05)/*定义了一个信号量模块的错误码，表示在中断期间调用了该API，这是被禁止的*/
/**
* @ingroup los_sem
@ -117,9 +118,9 @@ extern "C" {
*
* Value: 0x02000706.
*
* Solution: Do not call LOS_SemPend when task scheduling is locked.
* Solution: Do not call LOS_SemPend when task scheduling is locked.解决该错误的方法：在任务调度被锁定时不要调用LOS_SemPend函数
*/
#define LOS_ERRNO_SEM_PEND_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x06)
#define LOS_ERRNO_SEM_PEND_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x06)/*定义了一个信号量模块的错误码，表示由于任务调度被锁定，任务无法请求信号量*/
/**
* @ingroup los_sem
@ -127,9 +128,9 @@ extern "C" {
*
* Value: 0x02000707.
*
* Solution: Change the passed-in parameter value to the value within the valid range.
* Solution: Change the passed-in parameter value to the value within the valid range.解决该错误的方法：将传入的参数值更改为有效范围内的值。
*/
#define LOS_ERRNO_SEM_TIMEOUT LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x07)
#define LOS_ERRNO_SEM_TIMEOUT LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x07)/*定义了一个信号量模块的错误码，表示请求信号量超时*/
/**
* @ingroup los_sem
@ -137,9 +138,9 @@ extern "C" {
*
* Value: 0x02000708.
*
* Solution: Perform corresponding operations based on the requirements in the code context.
* Solution: Perform corresponding operations based on the requirements in the code context.解决该错误的方法：根据代码上下文的要求执行相应的操作。
*/
#define LOS_ERRNO_SEM_OVERFLOW LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x08)
#define LOS_ERRNO_SEM_OVERFLOW LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x08)/*定义了一个信号量模块的错误码，表示信号量释放的次数超过了允许的最大次数
/**
* @ingroup los_sem
@ -148,9 +149,9 @@ extern "C" {
*
* Value: 0x02000709.
*
* Solution: Delete the semaphore after awaking all tasks that are waiting on the semaphore.
* Solution: Delete the semaphore after awaking all tasks that are waiting on the semaphore.解决该错误的方法，即在唤醒等待信号量的所有任务后删除信号量
*/
#define LOS_ERRNO_SEM_PENDED LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x09)
#define LOS_ERRNO_SEM_PENDED LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x09)/*定义了一个信号量模块的错误码，表示等待信号量的任务队列不为空*/
/**
* @ingroup los_sem
@ -159,10 +160,10 @@ extern "C" {
*
* Value: 0x0200070A.
*
* Solution: Do not call the API in the system-level callback.
* @deprecated This error code is obsolete since LiteOS 5.0.0.
* Solution: Do not call the API in the system-level callback.解决该错误的方法，即不要在系统级回调中调用该API。
* @deprecated This error code is obsolete since LiteOS 5.0.0.该错误码自LiteOS 5.0.0版本起已经过时。
*/
#define LOS_ERRNO_SEM_PEND_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x0A)
#define LOS_ERRNO_SEM_PEND_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x0A)/*定义了一个信号量模块的错误码，表示在系统级回调中调用了该API，这是被禁止的*/
/**
* @ingroup los_sem
@ -187,7 +188,8 @@ extern "C" {
* @see LOS_SemDelete | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle);
extern UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle);/*这段代码声明了一个函数LOS_SemCreate，用于创建信号量。该函数根据传入的初始可用信号量数量，
创建一个信号量控制结构，并返回该信号量控制结构的ID。函数的返回值包括多种情况，如传入的参数为空指针、传入的初始可用信号量数量超过最大数量、没有可用的信号量控制结构等。*/
/**
* @ingroup los_sem
@ -212,7 +214,7 @@ extern UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle);
* @see LOS_SemCreate | LOS_SemDelete
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle);
extern UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle);/*声明了一个函数原型 LOS_BinarySemCreate，用于创建一个二进制信号量。*/
/**
* @ingroup los_sem
@ -235,7 +237,7 @@ extern UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle);
* @see LOS_SemCreate | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SemDelete(UINT32 semHandle);
extern UINT32 LOS_SemDelete(UINT32 semHandle);/*这段代码定义了一个函数LOS_SemDelete，用于删除一个信号量的控制结构*/
/**
* @ingroup los_sem
@ -272,7 +274,19 @@ extern UINT32 LOS_SemDelete(UINT32 semHandle);
* @see LOS_SemPost | LOS_SemCreate | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SemPend(UINT32 semHandle, UINT32 timeout);
extern UINT32 LOS_SemPend(UINT32 semHandle, UINT32 timeout);/*该函数用于请求一个信号量
通过semHandle参数指定要请求的信号量控制结构的ID，该ID是在信号量创建时获得的。
timeout参数指定等待信号量的超时时间，如果timeout值为0，表示不会等待信号量。如果timeout值为0xFFFFFFFF，表示会一直等待信号量。超时时间单位为Tick。
函数返回值为操作结果：
若返回值为LOS_ERRNO_SEM_INVALID，表示传入的semHandle值无效。
若返回值为LOS_ERRNO_SEM_UNAVAILABLE，表示没有可用的信号量资源。
若返回值为LOS_ERRNO_SEM_PEND_INTERR，表示在中断 [Something went wrong, please try again later.]
*/
/**
* @ingroup los_sem
@ -294,7 +308,12 @@ extern UINT32 LOS_SemPend(UINT32 semHandle, UINT32 timeout);
* @see LOS_SemPend | LOS_SemCreate | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SemPost(UINT32 semHandle);
extern UINT32 LOS_SemPost(UINT32 semHandle);/*这段代码定义了一个函数LOS_SemPost，用于释放一个信号量*/
/*LOS_SemPost用于释放由semHandle指定的信号量控制结构。
若释放前没有先创建指定的信号量，则会返回LOS_ERRNO_SEM_INVALID。
若信号量释放的次数超过允许的最大次数，则会返回LOS_ERRNO_SEM_OVERFLOW。
若成功释放信号量，则会返回LOS_OK。
此函数依赖于LOS_SemPend、LOS_SemCreate和LOS_BinarySemCreate函数。*/
#ifdef __cplusplus
#if __cplusplus

22
src/kernel/include/los_slab.h
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.
* --------------------------------------------------------------------------- */
/*以上代码是关于内存管理中的slab功能的实现。Slab是一种分配固定大小的内存块的机制，用于提高内存分配和释放的效率。以上代码提供了对slab内存分配器的配置和定义*/
/**
* @defgroup los_slab Slab
* @ingroup kernel
@ -46,9 +46,9 @@ extern "C" {
* @ingroup los_slab
* total size of each slab class.
*/
#define SLAB_MEM_ALLOCATOR_SIZE 512U
#define SLAB_MEM_ALLOCATOR_SIZE 512U /*宏定义SLAB_MEM_ALLOCATOR_SIZE表示每个slab class（一种内存分配方式）所需要的总大小为512字节*/
#define SLAB_BASIC_NEED_SIZE 0x1000
#define SLAB_BASIC_NEED_SIZE 0x1000 /*宏定义SLAB_BASIC_NEED_SIZE表示内存分配时最小需要的空间为0x1000字节（即4KB）。*/
/**
* @ingroup los_slab
@ -63,7 +63,14 @@ enum SlabBucketSizeType {
#define SLAB_MEM_BUCKET_SIZE_TYPE SLAB_BUCKET_SIZE_HALF_OF_HEAP
#endif
/*这段代码主要是用于配置和定义slab内存分配器中内存块大小的相关选项。*/
/*这段代码定义了一个枚举类型SlabBucketSizeType，用于表示slab bucket（内存块）的大小类型
如果宏定义LOSCFG_KERNEL_MEM_SLAB_AUTO_EXPANSION_MODE被定义，那么枚举类型SlabBucketSizeType将会被定义。
枚举类型SlabBucketSizeType包含以下取值：
SLAB_BUCKET_SIZE_HALF_OF_HEAP：表示slab内存块可以使用堆内存大小的一半。
SLAB_BUCKET_SIZE_QUARTER_OF_HEAP：表示slab内存块可以使用堆内存大小的四分之一。
SLAB_BUCKET_SIZE_TYPE_MAX：表示枚举类型的最大取值。
宏定义SLAB_MEM_BUCKET_SIZE_TYPE被设置为SLAB_BUCKET_SIZE_HALF_OF_HEAP，表示默认情况下slab内存块的大小为堆内存大小的一半。*/
/**
* @ingroup los_slab
* @brief configure slab size.
@ -86,8 +93,11 @@ enum SlabBucketSizeType {
* </ul>
* @since Huawei LiteOS V200R003C00
*/
extern VOID LOS_SlabSizeCfg(UINT32 *cfg, UINT32 cnt);
extern VOID LOS_SlabSizeCfg(UINT32 *cfg, UINT32 cnt);/*段代码是关于操作系统内存管理中的slab功能的配置函数。Slab是一种分配固定大小的内存块的机制，
用于提高内存分配和释放的效率*/
/*该函数LOS_SlabSizeCfg用于配置slab的大小。它接受两个参数：
cfg：指向slab大小配置表的指针。这个配置表包含了每个slab类的大小信息。
cnt：slab类的数量，必须与配置表中的项数相匹配*/
#ifdef __cplusplus
#if __cplusplus
}

74
src/kernel/include/los_spinlock.h
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.
*---------------------------------------------------------------------------*/
/*以上代码实现了自旋锁的基本操作，并根据多处理器系统和非多处理器系统分别进行了处理*/
/**
* @defgroup los_spinlock Spinlock
* @ingroup kernel
@ -55,13 +55,19 @@ extern "C" {
#define LOCKDEP_CHECK_OUT(lock) OsLockDepCheckOut(lock)
#define LOCKDEP_CLEAR_LOCKS() OsLockdepClearSpinlocks()
#define SPIN_LOCK_INITIALIZER(lockName) \
#define SPIN_LOCK_INITIALIZER(lockName) \/*这段代码看起来是定义了一个自旋锁的初始化器。不同的编译选项将定义不同的初始化器*/
{ \
.rawLock = 0U, \
.cpuid = (UINT32)(-1), \
.owner = SPINLOCK_OWNER_INIT, \
.name = #lockName, \
}
/*当预定义宏为真时，SPIN_LOCK_INITIALIZER宏会被展开为一个结构体初始化器，其中包含了一些成员变量的初始化，包括：
.rawLock：自旋锁的原始锁变量，初始化为0;
.cpuid：持有自旋锁的CPU编号，初始化为-1;
.owner：自旋锁的拥有者，初始化为SPINLOCK_OWNER_INIT；
.name：自旋锁的名称，初始化为锁的名称字符串。
当预定义宏为假时，SPIN_LOCK_INITIALIZER宏将被定义为空。*/
#else
#define LOCKDEP_CHECK_IN(lock)
#define LOCKDEP_RECORD(lock)
@ -72,7 +78,8 @@ extern "C" {
.rawLock = 0U, \
}
#endif
/*
定义了一些空的宏，如LOCKDEP_CHECK_IN、LOCKDEP_RECORD、LOCKDEP_CHECK_OUT和LOCKDEP_CLEAR_LOCKS，这些宏在预定义的宏为假时会被定义为空操作。*/
/**
* @ingroup los_spinlock
* <ul>
@ -87,8 +94,8 @@ extern "C" {
* obtained. For time-consuming operation, the mutex lock can be used instead of spinlock.</li>
* </ul>
*/
#define SPIN_LOCK_INIT(lock) SPIN_LOCK_S lock = SPIN_LOCK_INITIALIZER(lock)
#define SPIN_LOCK_INIT(lock) SPIN_LOCK_S lock = SPIN_LOCK_INITIALIZER(lock)/*这段代码定义了一个宏SPIN_LOCK_INIT，用于将输入参数lock定义为自旋锁，并静态地初始化自旋锁*/
/*该宏主要用于定义和初始化自旋锁，用于保护对共享资源的短时间访问。在使用自旋锁时，需要注意避免使用在耗时较长的操作上，以免影响整体系统性能*/
/**
* @ingroup los_spinlock
* Define the structure of spinlock.
@ -104,8 +111,13 @@ struct Spinlock {
const CHAR *name; /**< the lock owner's task name. It is defined only when
LOSCFG_KERNEL_SMP_LOCKDEP is defined. */
#endif
};
};/*这段代码定义了一个名为Spinlock的结构体，用于表示自旋锁的结构*/
/*结构体Spinlock包括以下成员变量：
rawLock：表示原始的自旋锁，类型为size_t。
cpuid：表示获取该锁的CPU编号，类型为UINT32。当预定义宏LOSCFG_KERNEL_SMP_LOCKDEP被定义时，此成员变量才有效。
owner：表示锁拥有者的任务控制块指针，类型为VOID*。当预定义宏LOSCFG_KERNEL_SMP_LOCKDEP被定义时，此成员变量才有效。
name：表示锁拥有者任务的名称，类型为const CHAR*。当预定义宏LOSCFG_KERNEL_SMP_LOCKDEP被定义时，此成员变量才有效*/
#ifdef LOSCFG_KERNEL_SMP
/**
* @ingroup los_spinlock
@ -146,7 +158,14 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinLock(SPIN_LOCK_S *lock)
LOCKDEP_CHECK_IN(lock);
ArchSpinLock(&lock->rawLock);
LOCKDEP_RECORD(lock);
}
}/*这段代码实现了自旋锁的加锁操作，函数名称为LOS_SpinLock。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要加锁的自旋锁。*/
/*在函数内部，首先调用LOS_TaskLock函数禁用调度器，以确保当前任务不会被切换出去。然后调用LOCKDEP_CHECK_IN宏和LOCKDEP_RECORD宏，用于记录锁依赖关系，
并最终调用ArchSpinLock函数对自旋锁进行加锁操作。
需要注意的是，如果预定义宏LOSCFG_KERNEL_SMP_LOCKDEP被定义，那么在调用LOS_SpinLock之前必须先调用LOS_LockdepCpuTryInit函数进行初始化。否则，在自旋
锁使用过程中可能会引发锁依赖检测相关的错误。
此外，该函数会等待获取自旋锁，直到成功获得自旋锁。如果自旋锁已经被其他线程占用，则当前线程会进入自旋等待状态，直到其他线程释放了该自旋锁。
最后，该函数在单处理器模式下没有任何效果，只有在多处理器（SMP）模式下才有效*/
/**
* @ingroup los_spinlock
@ -185,7 +204,11 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE INT32 LOS_SpinTrylock(SPIN_LOCK_S *lock)
}
return ret;
}
}/*这段代码实现了自旋锁的尝试加锁操作，函数名称为LOS_SpinTrylock。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要尝试加锁的自旋锁*/
/*首先调用LOS_TaskLock函数禁用调度器，以确保当前任务不会被切换出去。然后调用LOCKDEP_CHECK_IN宏用于记录锁依赖关系，并最终调用ArchSpinTrylock函数尝试对自旋
锁进行加锁操作。
如果成功获取到自旋锁（ArchSpinTrylock返回值为LOS_OK），则调用LOCKDEP_RECORD宏记录锁依赖关系，并返回LOS_OK表示成功获取自旋锁。如果自旋锁已经被其他线程占用
，ArchSpinTrylock将直接返回LOS_NOK，表示获取自旋锁*/
/**
* @ingroup los_spinlock
@ -215,7 +238,10 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinUnlock(SPIN_LOCK_S *lock)
/* restore the scheduler flag */
LOS_TaskUnlock();
}
}/*这段代码实现了自旋锁的解锁操作，函数名称为LOS_SpinUnlock。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要解锁的自旋锁。*/
/*在函数内部，首先调用LOCKDEP_CHECK_OUT宏用于检查并记录锁依赖关系，并最终调用ArchSpinUnlock函数对自旋锁进行解锁操作。
然后，通过调用LOS_TaskUnlock函数恢复调度器的状态，允许任务切换。*/
/**
* @ingroup los_spinlock
@ -249,8 +275,11 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinLockSave(SPIN_LOCK_S *lock, UI
{
*intSave = LOS_IntLock();
LOS_SpinLock(lock);
}
}/*这段代码实现了自旋锁的带保存中断状态的加锁操作，函数名称为LOS_SpinLockSave。它接收一个类型为SPIN_LOCK_S*的指针参数lock，
表示要加锁的自旋锁；另外还接收一个类型为UINT32*的指针参数intSave，表示用于保存中断状态的指针*/
/*在函数内部，首先调用LOS_IntLock函数禁用所有中断，并将禁用前的中断状态保存到intSave指向的地址中。然后调用LOS_SpinLock函数对自旋锁进行加锁操作。
*/
/**
* @ingroup los_spinlock
* @brief Unlock the spinlock and restore the interrupt flag.
@ -279,8 +308,11 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinUnlockRestore(SPIN_LOCK_S *loc
{
LOS_SpinUnlock(lock);
LOS_IntRestore(intSave);
}
}/*这段代码实现了自旋锁的解锁操作，并恢复中断状态。函数名称为LOS_SpinUnlockRestore。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要解锁的自旋锁；
另外还接收一个类型为UINT32的参数intSave，表示要恢复的中断状态。*/
/*在函数内部，首先调用LOS_SpinUnlock函数对自旋锁进行解锁操作，然后调用LOS_IntRestore函数恢复中断状态，参数为之前保存的中断状态intSave。
需要注意的是，该函数只能在调用LOS_SpinLockSave函数之后调用，并且传入的intSave参数应该是由LOS_SpinLockSave函数返回的中断状态保存值*/
/**
* @ingroup los_spinlock
* @brief Check if holding the spinlock.
@ -305,8 +337,9 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinUnlockRestore(SPIN_LOCK_S *loc
LITE_OS_SEC_ALW_INLINE STATIC INLINE BOOL LOS_SpinHeld(const SPIN_LOCK_S *lock)
{
return (lock->rawLock != 0);
}
}/*这段代码实现了检查自旋锁是否被持有的功能。函数名称为LOS_SpinHeld。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要检查的自旋锁*/
/*在函数内部，通过判断自旋锁的rawLock成员变量是否为0来确定自旋锁是否被持有。如果rawLock不为0，则表示自旋锁被持有，返回TRUE；否则，表示自旋锁未被持有，返回FALSE*/
/**
* @ingroup los_spinlock
* @brief Spinlock dynamic initialization.
@ -339,8 +372,13 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinInit(SPIN_LOCK_S *lock)
lock->owner = SPINLOCK_OWNER_INIT;
lock->name = "spinlock";
#endif
}
}/*这段代码是用于动态初始化自旋锁的函数LOS_SpinInit。*/
/*函数接受一个类型为SPIN_LOCK_S*的指针参数lock，表示需要初始化的自旋锁。
在函数内部，首先将自旋锁的rawLock成员变量设置为0，表示自旋锁未被持有。然后，根据配置项LOSCFG_KERNEL_SMP_LOCKDEP的值进行条件编译。
如果LOSCFG_KERNEL_SMP_LOCKDEP被定义，则对其他成员变量进行初始化。其中，cpuid成员变量被初始化为-1，表示自旋锁未被任何CPU持有；owner成员变量被初始化为
SPINLOCK_OWNER_INIT，表示自旋锁的初始状态；name成员变量被初始化为"spinlock"，表示自旋锁的名称。
如果LOSCFG_KERNEL_SMP_LOCKDEP未被定义，则不执行任何操作。*/
#else
/*
@ -385,7 +423,15 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinInit(SPIN_LOCK_S *lock)
{
(VOID)lock;
}
/*上述代码中，是对于非多处理器系统的处理。这些函数并不实际处理自旋锁，而是为了统一代码的编写，以方便驱动程序、供应商等进行开发。
以下是这些函数的说明：
LOS_SpinLock：空函数，不执行任何操作。
LOS_SpinTrylock：空函数，不执行任何操作，并返回LOS_OK。
LOS_SpinUnlock：空函数，不执行任何操作。
LOS_SpinLockSave：空函数，不执行任何操作，并通过指针参数intSave保存中断状态。
LOS_SpinUnlockRestore：空函数，不执行任何操作，并使用参数intSave恢复中断状态。
LOS_SpinHeld：空函数，不执行任何操作，并返回TRUE表示自旋锁已被持有。
LOS_SpinInit：空函数，不执行任何操作。*/
#endif
#ifdef __cplusplus

109
src/kernel/include/los_swtmr.h
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.
* --------------------------------------------------------------------------- */
/*这段代码是关于软件定时器的管理接口，主要包括软件定时器的创建、启动、停止、删除等操作。这段代码提供了一套完整的软件定时器管理接口，方便开发人员在嵌入式系统中实现基于时间的任务调度和处理。*/
/**
* @defgroup los_swtmr Software timer
* @ingroup kernel
@ -51,15 +51,15 @@ extern "C" {
*
* Solution: Define the timeout handling function.
*/
#define LOS_ERRNO_SWTMR_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x00)
#define LOS_ERRNO_SWTMR_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x00)/**/
/*错误代码LOS_ERRNO_SWTMR_PTR_NULL表示软件定时器的超时处理函数为空。这意味着当定时器到期时，没有要执行的函数*/
/**
* @ingroup los_swtmr
* Software timer error code: The expiration time is 0.
*
* Value: 0x02000301.
*
* Solution: Re-define the expiration time.
* Solution: Re-define the expiration time./*要解决此错误，您需要为软件定时器定义一个超时处理函数。该函数将在定时器到期时被调用，并执行所需的操作。
*/
#define LOS_ERRNO_SWTMR_INTERVAL_NOT_SUITED LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x01)
@ -69,17 +69,17 @@ extern "C" {
*
* Value: 0x02000302.
*
* Solution: Check the mode value. The value range is [0,3].
* Solution: Check the mode value. The value range is [0,3]./*要解决此错误，您需要重新定义定时器的到期时间。确保到期时间大于0，并且与您的需求相符。
*/
#define LOS_ERRNO_SWTMR_MODE_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x02)
/*错误代码LOS_ERRNO_SWTMR_INTERVAL_NOT_SUITED表示定时器的到期时间为0。这意味着定时器的到期时间设置不合适*/
/**
* @ingroup los_swtmr
* Software timer error code: The passed-in software timer ID is NULL.
*
* Value: 0x02000303.
*
* Solution: Define the software timer ID before passing it in.
* Solution: Define the software timer ID before passing it in.要解决此错误，您需要在传入函数之前定义软件定时器ID。确保为软件定时器分配一个有效的ID，并在使用该ID时进行传入。
*/
#define LOS_ERRNO_SWTMR_RET_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x03)
@ -90,20 +90,20 @@ extern "C" {
* Value: 0x02000304.
*
* Solution: Re-configure the permitted maximum number of software timers, or wait for a software timer to become
* available.
* available.要解决此错误，您可以重新配置允许的最大软件定时器数量
*/
#define LOS_ERRNO_SWTMR_MAXSIZE LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x04)
#define LOS_ERRNO_SWTMR_MAXSIZE LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x04)/
/*错误代码LOS_ERRNO_SWTMR_MAXSIZE表示软件定时器的数量超过了配置的允许最大数量。*/
/**
* @ingroup los_swtmr
* Software timer error code: Invalid software timer ID.
*
* Value: 0x02000305.
*
* Solution: Pass in a valid software timer ID.
* Solution: Pass in a valid software timer ID.解决方案：传入有效的软件计时器ID
*/
#define LOS_ERRNO_SWTMR_ID_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x05)
/*错误代码LOS_ERRNO_SWTMR_ID_INVALID表示软件计时器ID无效。*/
/**
* @ingroup los_swtmr
* Software timer error code: The software timer is not created.
@ -113,7 +113,7 @@ extern "C" {
* Solution: Create a software timer.
*/
#define LOS_ERRNO_SWTMR_NOT_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x06)
/*错误代码LOS_ERRNO_SWTMR_NOT_CREATED表示软件计时器未创建*/
/**
* @ingroup los_swtmr
* Software timer error code: Insufficient memory for software timer linked list creation.
@ -121,20 +121,21 @@ extern "C" {
* Value: 0x02000307.
*
* Solution: Allocate bigger memory partition to software timer linked list creation.
* 解决方案：为软件定时器链表创建分配更大的内存分区
*/
#define LOS_ERRNO_SWTMR_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x07)
/*错误代码LOS_ERRNO_SWTMR_NO_MEMORY内存不足，无法创建软件计时器链表*/
/**
* @ingroup los_swtmr
* Software timer error code: Invalid configured number of software timers.
*
* Value: 0x02000308.
*
* Solution: Re-configure the number of software timers.
* Solution: Re-configure the number of software timers.解决方案：重新配置软件计时器的数量。
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_SWTMR_MAXSIZE_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x08)
/*软件计时器错误代码：配置的软件计时器数量无效*/
/**
* @ingroup los_swtmr
* Software timer error code: The software timer is being used during an interrupt.
@ -142,60 +143,61 @@ extern "C" {
* Value: 0x02000309.
*
* Solution: Change the source code and do not use the software timer during an interrupt.
* 解决方案：更改源代码，在中断期间不要使用软件计时器
*/
#define LOS_ERRNO_SWTMR_HWI_ACTIVE LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x09)
/*软件计时器错误代码：软件计时器在中断期间使用*/
/**
* @ingroup los_swtmr
* Software timer error code: Insufficient memory allocated by membox.
*
* Value: 0x0200030a.
*
* Solution: Expand the memory allocated by membox.
* Solution: Expand the memory allocated by membox.解决方案：扩展membox分配的内存
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_SWTMR_HANDLER_POOL_NO_MEM LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x0a)
/*软件计时器错误代码：membox分配的内存不足*/
/**
* @ingroup los_swtmr
* Software timer error code: The software timer queue fails to be created.
*
* Value: 0x0200030b.
*
* Solution: Check whether more memory can be allocated to the queue to be created.
* Solution: Check whether more memory can be allocated to the queue to be created.解决方案：检查是否可以为要创建的队列分配更多内存
*/
#define LOS_ERRNO_SWTMR_QUEUE_CREATE_FAILED LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x0b)
/*软件计时器错误代码：无法创建软件计时器队列。*/
/**
* @ingroup los_swtmr
* Software timer error code: The software timer task fails to be created.
*
* Value: 0x0200030c.
*
* Solution: Check whether the memory is sufficient and re-create the task.
* Solution: Check whether the memory is sufficient and re-create the task.解决方案：检查内存是否足够，然后重新创建任务。
*/
#define LOS_ERRNO_SWTMR_TASK_CREATE_FAILED LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x0c)
/*软件计时器错误代码：无法创建软件计时器任务。*/
/**
* @ingroup los_swtmr
* Software timer error code: The software timer is not started.
*
* Value: 0x0200030d.
*
* Solution: Start the software timer.
* Solution: Start the software timer.解决方案：启动软件计时器
*/
#define LOS_ERRNO_SWTMR_NOT_STARTED LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x0d)
/*软件计时器错误代码：软件计时器未启动*/
/**
* @ingroup los_swtmr
* Software timer error code: Invalid software timer state.
*
* Value: 0x0200030e.
*
* Solution: Check the software timer state.
* Solution: Check the software timer state.解决方案：检查软件计时器状态
*/
#define LOS_ERRNO_SWTMR_STATUS_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x0e)
/*软件计时器错误代码：软件计时器状态无效*/
/**
* @ingroup los_swtmr
* Software timer error code: This error code is not in use temporarily.
@ -204,7 +206,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_SWTMR_SORTLIST_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x0f)
/*软件计时器错误代码：此错误代码暂时未使用*/
/**
* @ingroup los_swtmr
* Software timer error code: The passed-in number of remaining Ticks configured on the software timer is NULL.
@ -214,7 +216,7 @@ extern "C" {
* Solution: Define a variable of the number of remaining Ticks before passing in the number of remaining Ticks.
*/
#define LOS_ERRNO_SWTMR_TICK_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x10)
/*软件计时器错误代码：软件计时器上配置的传入的剩余Tick数为NULL*/
/**
* @ingroup los_swtmr
* Software timer error code: The software sortlink fails to be created.
@ -224,7 +226,7 @@ extern "C" {
* Solution: Check whether the memory is sufficient and re-create the sortlink.
*/
#define LOS_ERRNO_SWTMR_SORTLINK_CREATE_FAILED LOS_ERRNO_OS_ERROR(LOS_MOD_SWTMR, 0x11)
/*软件计时器错误代码：无法创建软件排序链接。*/
/**
* @ingroup los_swtmr
* Software timer mode
@ -237,7 +239,11 @@ enum enSwTmrType {
periodic software timer is enabled. The value
is 3. This mode is not supported temporarily. */
};
/*这段代码定义了软件定时器的模式，使用了一个枚举类型enSwTmrType来表示。其中包含以下几种模式：
LOS_SWTMR_MODE_ONCE：一次性软件定时器，值为0。
LOS_SWTMR_MODE_PERIOD：周期性软件定时器，值为1。
LOS_SWTMR_MODE_NO_SELFDELETE：一次性软件定时器，但不会自我删除，值为2。
LOS_SWTMR_MODE_OPP：在一次性定时器完成定时后，启用周期性软件定时器。该模式的值为3。目前暂不支持该模式*/
/**
* @ingroup los_swtmr
* @brief Define the type of a callback function that handles software timer timeout.
@ -257,7 +263,7 @@ enum enSwTmrType {
* @since Huawei LiteOS V100R001C00
*/
typedef VOID (*SWTMR_PROC_FUNC)(UINTPTR arg);
/*这段代码定义了一个回调函数类型SWTMR_PROC_FUNC，用于处理软件定时器超时事件。该回调函数在软件定时器超时时被调用*/
/**
* @ingroup los_swtmr
* @brief Start a software timer.
@ -280,6 +286,12 @@ typedef VOID (*SWTMR_PROC_FUNC)(UINTPTR arg);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SwtmrStart(UINT16 swtmrId);
/*这段代码是一个软件定时器模块中的函数LOS_SwtmrStart的声明。它用于启动一个指定ID的软件定时器。
函数的返回值可能有以下几种情况：
LOS_ERRNO_SWTMR_ID_INVALID：无效的软件定时器ID。
LOS_ERRNO_SWTMR_NOT_CREATED：软件定时器未创建。
LOS_ERRNO_SWTMR_STATUS_INVALID：无效的软件定时器状态。
LOS_OK：成功启动软件定时器。*/
/**
* @ingroup los_swtmr
@ -304,7 +316,13 @@ extern UINT32 LOS_SwtmrStart(UINT16 swtmrId);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SwtmrStop(UINT16 swtmrId);
/*这段代码是一个软件定时器模块中的函数LOS_SwtmrStop的声明。它用于停止一个指定ID的软件定时器
函数的返回值可能有以下几种情况：
LOS_ERRNO_SWTMR_ID_INVALID：无效的软件定时器ID。
LOS_ERRNO_SWTMR_NOT_CREATED：未创建软件定时器。
LOS_ERRNO_SWTMR_NOT_STARTED：软件定时器未启动。
LOS_ERRNO_SWTMR_STATUS_INVALID：无效的软件定时器状态。
LOS_OK：成功停止软件定时器。*/
/**
* @ingroup los_swtmr
* @brief Obtain the number of remaining Ticks configured on a software timer.
@ -331,7 +349,14 @@ extern UINT32 LOS_SwtmrStop(UINT16 swtmrId);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SwtmrTimeGet(UINT16 swtmrId, UINT32 *tick);
/*这段代码是一个软件定时器模块中的函数LOS_SwtmrTimeGet的声明。它用于获取指定ID的软件定时器配置的剩余Ticks数
函数的返回值可能有以下几种情况：
LOS_ERRNO_SWTMR_ID_INVALID：无效的软件定时器ID。
LOS_ERRNO_SWTMR_TICK_PTR_NULL：输入参数tick为NULL指针。
LOS_ERRNO_SWTMR_NOT_CREATED：未创建软件定时器。
LOS_ERRNO_SWTMR_NOT_STARTED：软件定时器未启动。
LOS_ERRNO_SWTMR_STATUS_INVALID：无效的软件定时器状态。
LOS_OK：成功获取剩余Ticks数。*/
/**
* @ingroup los_swtmr
* @brief Create a software timer.
@ -367,7 +392,14 @@ extern UINT32 LOS_SwtmrTimeGet(UINT16 swtmrId, UINT32 *tick);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SwtmrCreate(UINT32 interval, UINT8 mode, SWTMR_PROC_FUNC handler, UINT16 *swtmrId, UINTPTR arg);
/*这段代码是一个软件定时器模块中的函数LOS_SwtmrCreate的声明。它用于创建一个具有指定定时时长、超时处理函数和触发模式的软件定时器，并返回一个引用该软件定时器的句柄
函数的返回值可能有以下几种情况：
LOS_ERRNO_SWTMR_INTERVAL_NOT_SUITED：软件定时器超时间隔为0。
LOS_ERRNO_SWTMR_MODE_INVALID：无效的软件定时器触发模式。
LOS_ERRNO_SWTMR_PTR_NULL：处理软件定时器超时的回调函数为NULL。
LOS_ERRNO_SWTMR_RET_PTR_NULL：传入的软件定时器ID为NULL。
LOS_ERRNO_SWTMR_MAXSIZE：软件定时器数量超过配置的最大数量。
LOS_OK：成功创建软件定时器。*/
/**
* @ingroup los_swtmr
* @brief Delete a software timer.
@ -390,7 +422,12 @@ extern UINT32 LOS_SwtmrCreate(UINT32 interval, UINT8 mode, SWTMR_PROC_FUNC handl
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_SwtmrDelete(UINT16 swtmrId);
/*这段代码是一个软件定时器模块中的函数LOS_SwtmrDelete的声明。它用于删除一个软件定时器。
函数的返回值可能有以下几种情况：
LOS_ERRNO_SWTMR_ID_INVALID：无效的软件定时器ID。
LOS_ERRNO_SWTMR_NOT_CREATED：该软件定时器未被创建。
LOS_ERRNO_SWTMR_STATUS_INVALID：无效的软件定时器状态。
LOS_OK：成功删除软件定时器。*/
#ifdef __cplusplus
#if __cplusplus
}

2
src/kernel/include/los_sys.h
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.
* --------------------------------------------------------------------------- */
/*这个头文件提供了系统时间模块的接口和基本定义，为系统时间的管理提供了必要的支持*/
/**
* @defgroup los_sys System time
* @ingroup kernel

27
src/kernel/include/los_tables.h
Unescape View File

@ -25,7 +25,8 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */
/*以上代码是LiteOS系统中定义表格的头文件，其中定义了一些宏用于在汇编代码中生成指定名称和标签的全局符号，用于在LiteOS系统中实现一些底层硬件操作。
同时还定义了一些用于存储数据的节（section），以确保在可执行文件中包含该数据。此外，还定义了一些用于设置表的类型或属性的宏。*/
#ifndef _LOS_TABLES_H
#define _LOS_TABLES_H
@ -47,7 +48,7 @@ extern "C" {
".previous\n" \
)
#endif
/*这段代码定义了一个宏LOS_HAL_TABLE_WOW_BEGIN，用于在汇编代码中声明一个LiteOS的表格开始位置。该宏使用了一些特定的汇编指令和标签定义*/
#ifndef LOS_HAL_TABLE_WOW_END
#define LOS_HAL_TABLE_WOW_END(label, name) \
__asm__(".section \".liteos.table." X_STRING(name) ".wow.finish\",\"aw\"\n" \
@ -58,7 +59,7 @@ extern "C" {
".previous\n" \
)
#endif
/*。该代码定义了一个名为LOS_HAL_TABLE_WOW_END的宏，该宏的作用是在汇编代码中生成一个指定名称和标签的全局符号，用于在LiteOS系统中实现一些底层硬件操作。*/
#ifndef LOS_HAL_TABLE_SCATTER_BEGIN
#define LOS_HAL_TABLE_SCATTER_BEGIN(label, name) \
__asm__(".section \".liteos.table." X_STRING(name) ".scatter.begin\",\"aw\"\n" \
@ -69,7 +70,7 @@ extern "C" {
".previous\n" \
)
#endif
/*这是另一段C预处理器宏定义代码。该代码定义了一个名为LOS_HAL_TABLE_SCATTER_BEGIN的宏，该宏的作用是在汇编代码中生成一个指定名称和标签的全局符号，用于在LiteOS系统中实现一些底层硬件操作。*/
#ifndef LOS_HAL_TABLE_SCATTER_END
#define LOS_HAL_TABLE_SCATTER_END(label, name) \
__asm__(".section \".liteos.table." X_STRING(name) ".scatter.finish\",\"aw\"\n" \
@ -80,7 +81,7 @@ extern "C" {
".previous\n" \
)
#endif
/*该代码定义了一个名为LOS_HAL_TABLE_SCATTER_END的宏，用于在LiteOS系统中生成汇编代码中的全局符号*/
#ifndef LOS_HAL_TABLE_BEGIN
#define LOS_HAL_TABLE_BEGIN(label, name) \
__asm__(".section \".liteos.table." X_STRING(name) ".begin\",\"aw\"\n" \
@ -91,7 +92,7 @@ extern "C" {
".previous\n" \
)
#endif
/*该代码定义了一个名为LOS_HAL_TABLE_BEGIN的宏，该宏的作用是在汇编代码中生成一个指定名称和标签的全局符号，用于在LiteOS系统中实现一些底层硬件操作。*/
#ifndef LOS_HAL_TABLE_END
#define LOS_HAL_TABLE_END(label, name) \
__asm__(".section \".liteos.table." X_STRING(name) ".finish\",\"aw\"\n" \
@ -102,41 +103,41 @@ extern "C" {
".previous\n" \
)
#endif
/*该代码定义了一个名为LOS_HAL_TABLE_END的宏，用于在LiteOS系统中生成汇编代码中的全局符号*/
/* This macro must be applied to any types whose objects are to be placed in tables */
#ifndef LOS_HAL_TABLE_TYPE
#define LOS_HAL_TABLE_TYPE LOSBLD_ATTRIB_ALIGN(LOSARC_ALIGNMENT)
#endif
/*通过这个宏的定义，可以在代码中统一设置表的类型或属性，使得系统中使用的表在对齐等方面具有统一的特性*/
#ifndef LOS_HAL_TABLE_EXTRA
#define LOS_HAL_TABLE_EXTRA(name) \
LOSBLD_ATTRIB_SECTION(".liteos.table." X_STRING(name) ".extra")
#endif
/*该代码定义了一个名为LOS_HAL_TABLE_EXTRA的宏，用于在LiteOS系统中生成汇编代码中的节（section）名称*/
#ifndef LOS_HAL_TABLE_WOW_ENTRY
#define LOS_HAL_TABLE_WOW_ENTRY(name) \
LOSBLD_ATTRIB_SECTION(".liteos.table." X_STRING(name) ".wow.data") \
LOSBLD_ATTRIB_USED
#endif
/*这段代码定义了一个名为LOS_HAL_TABLE_WOW_ENTRY的宏，用于在LiteOS系统中生成汇编代码中的节（section）名称，并将该符号标记为被使用。*/
#ifndef LOS_HAL_TABLE_SCATTER_ENTRY
#define LOS_HAL_TABLE_SCATTER_ENTRY(name) \
LOSBLD_ATTRIB_SECTION(".liteos.table." X_STRING(name) ".scatter.data") \
LOSBLD_ATTRIB_USED
#endif
/*这段代码定义了一个名为LOS_HAL_TABLE_SCATTER_ENTRY的宏，用于在LiteOS系统中生成汇编代码中的节（section）名称，并将该符号标记为被使用*/
#ifndef LOS_HAL_TABLE_ENTRY
#define LOS_HAL_TABLE_ENTRY(name) \
LOSBLD_ATTRIB_SECTION(".liteos.table." X_STRING(name) ".data") \
LOSBLD_ATTRIB_USED
#endif
/*该宏的作用是定义一个通用的节（section），用于存储数据，并确保相关符号被正确使用和链接到系统的可执行文件中*/
#ifndef LOS_HAL_TABLE_QUALIFIED_ENTRY
#define LOS_HAL_TABLE_QUALIFIED_ENTRY(name, _qual) \
LOSBLD_ATTRIB_SECTION(".liteos.table." X_STRING(name) ".data." X_STRING(_qual)) \
LOSBLD_ATTRIB_USED
#endif
/*该宏的作用是定义一个用于存储特定类型数据的节（section），并将相关符号标记为被使用，以确保可执行文件中包含该数据*/
#ifdef __cplusplus
#if __cplusplus
}

180
src/kernel/include/los_task.h
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.
* --------------------------------------------------------------------------- */
/*该函数定义了一些任务错误情况以及一些关于任务处理的函数*/
/**
* @defgroup los_task Task
* @ingroup kernel
@ -58,7 +58,7 @@ extern "C" {
* automatically after the task is done.
*/
#define LOS_TASK_STATUS_DETACHED 0x0100U
/*LOS_TASK_STATUS_DETACHED是一个任务或者任务控制块状态的标志位。它表示任务处于自动删除状态。在这个状态下，任务会在执行完毕后自动被删除*/
/**
* @ingroup los_task
* Task error code: Insufficient memory for task creation.
@ -68,7 +68,7 @@ extern "C" {
* Solution: Allocate bigger memory partition to task creation.
*/
#define LOS_ERRNO_TSK_NO_MEMORY LOS_ERRNO_OS_FATAL(LOS_MOD_TSK, 0x00)
/*任务错误代码：内存不足，无法创建任务。*/
/**
* @ingroup los_task
* Task error code: Null parameter.
@ -78,7 +78,7 @@ extern "C" {
* Solution: Check the parameter.
*/
#define LOS_ERRNO_TSK_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x01)
/*任务错误代码：参数为Null*/
/**
* @ingroup los_task
* Task error code: The task stack is not aligned.
@ -88,7 +88,7 @@ extern "C" {
* Solution: Align the task stack.
*/
#define LOS_ERRNO_TSK_STKSZ_NOT_ALIGN LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x02)
/*任务错误代码：任务堆栈未对齐*/
/**
* @ingroup los_task
* Task error code: Incorrect task priority.
@ -98,7 +98,7 @@ extern "C" {
* Solution: Re-configure the task priority by referring to the priority range.
*/
#define LOS_ERRNO_TSK_PRIOR_ERROR LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x03)
/*任务错误代码：任务优先级不正确*/
/**
* @ingroup los_task
* Task error code: The task entrance is NULL.
@ -108,7 +108,7 @@ extern "C" {
* Solution: Define the task entrance function.
*/
#define LOS_ERRNO_TSK_ENTRY_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x04)
/*任务错误代码：任务入口为NULL*/
/**
* @ingroup los_task
* Task error code: The task name is NULL.
@ -118,7 +118,7 @@ extern "C" {
* Solution: Set the task name.
*/
#define LOS_ERRNO_TSK_NAME_EMPTY LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x05)
/*任务错误代码：任务名称为NULL*/
/**
* @ingroup los_task
* Task error code: The task stack size is too small.
@ -128,7 +128,7 @@ extern "C" {
* Solution: Expand the task stack.
*/
#define LOS_ERRNO_TSK_STKSZ_TOO_SMALL LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x06)
/*任务错误代码：任务堆栈太小*/
/**
* @ingroup los_task
* Task error code: Invalid task ID.
@ -138,7 +138,7 @@ extern "C" {
* Solution: Check the task ID.
*/
#define LOS_ERRNO_TSK_ID_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x07)
/*任务错误代码：任务ID无效*/
/**
* @ingroup los_task
* Task error code: The task is already suspended.
@ -148,7 +148,7 @@ extern "C" {
* Solution: Suspend the task after it is resumed.
*/
#define LOS_ERRNO_TSK_ALREADY_SUSPENDED LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x08)
/*任务错误代码：任务已挂起*/
/**
* @ingroup los_task
* Task error code: The task is not suspended.
@ -158,7 +158,7 @@ extern "C" {
* Solution: Suspend the task.
*/
#define LOS_ERRNO_TSK_NOT_SUSPENDED LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x09)
/*任务错误代码：任务未挂起*/
/**
* @ingroup los_task
* Task error code: The task is not created.
@ -168,7 +168,7 @@ extern "C" {
* Solution: Create the task.
*/
#define LOS_ERRNO_TSK_NOT_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x0a)
/*任务错误代码：未创建任务*/
/**
* @ingroup los_task
* Task error code: The task is locked when it is being deleted.
@ -178,7 +178,7 @@ extern "C" {
* Solution: Unlock the task.
*/
#define LOS_ERRNO_TSK_DELETE_LOCKED LOS_ERRNO_OS_FATAL(LOS_MOD_TSK, 0x0b)
/*任务错误代码：删除任务时该任务被锁定*/
/**
* @ingroup los_task
* Task error code: The task message is nonzero.
@ -189,7 +189,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_MSG_NONZERO LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x0c)
/*任务错误代码：任务消息为非零*/
/**
* @ingroup los_task
* Task error code: The task delay occurs during an interrupt.
@ -199,7 +199,7 @@ extern "C" {
* Solution: Perform this operation after exiting from the interrupt.
*/
#define LOS_ERRNO_TSK_DELAY_IN_INT LOS_ERRNO_OS_FATAL(LOS_MOD_TSK, 0x0d)
/*任务错误代码：任务延迟发生在中断期间*/
/**
* @ingroup los_task
* Task error code: The task delay occurs when the task is locked.
@ -209,7 +209,7 @@ extern "C" {
* Solution: Perform this operation after unlocking the task.
*/
#define LOS_ERRNO_TSK_DELAY_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x0e)
/*任务错误代码：任务锁定时会出现任务延迟*/
/**
* @ingroup los_task
* Task error code: The task yield occurs when the task is locked.
@ -219,7 +219,7 @@ extern "C" {
* Solution: Check the task.
*/
#define LOS_ERRNO_TSK_YIELD_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x0f)
/*任务错误代码：当任务被锁定时，任务将产生收益*/
/**
* @ingroup los_task
* Task error code: Only one task or no task is available for scheduling.
@ -229,7 +229,7 @@ extern "C" {
* Solution: Increase the number of tasks.
*/
#define LOS_ERRNO_TSK_YIELD_NOT_ENOUGH_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x10)
/*任务错误代码：只有一个任务或没有任务可用于计划*/
/**
* @ingroup los_task
* Task error code: No free task control block is available.
@ -239,7 +239,7 @@ extern "C" {
* Solution: Increase the number of task control blocks.
*/
#define LOS_ERRNO_TSK_TCB_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x11)
/*任务错误代码：没有可用的任务控制块*/
/**
* @ingroup los_task
* Task error code: The task hook function is not matchable.
@ -250,7 +250,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_HOOK_NOT_MATCH LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x12)
/*任务错误代码：任务挂钩函数不匹配*/
/**
* @ingroup los_task
* Task error code: The number of task hook functions exceeds the permitted upper limit.
@ -261,7 +261,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_HOOK_IS_FULL LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x13)
/*任务错误代码：任务挂钩函数的数量超过了允许的上限*/
/**
* @ingroup los_task
* Task error code: The operation is performed on the system-level task.
@ -272,7 +272,8 @@ extern "C" {
* Solution: Check the task ID and do not operate the system-level task.
*/
#define LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x14)
/*任务错误代码：该操作是在系统级任务上执行的。
*旧用法：该操作在空闲任务上执行（LOS_ERRNO_TSK_OPERATE_idle）*/
/**
* @ingroup los_task
* Task error code: The task that is being suspended is locked.
@ -282,7 +283,7 @@ extern "C" {
* Solution: Suspend the task after unlocking the task.
*/
#define LOS_ERRNO_TSK_SUSPEND_LOCKED LOS_ERRNO_OS_FATAL(LOS_MOD_TSK, 0x15)
/*任务错误代码：正在挂起的任务已锁定*/
/**
* @ingroup los_task
* Task error code: The task stack fails to be freed.
@ -293,7 +294,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_FREE_STACK_FAILED LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x17)
/*任务错误代码：无法释放任务堆栈*/
/**
* @ingroup los_task
* Task error code: The task stack area is too small.
@ -304,7 +305,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_STKAREA_TOO_SMALL LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x18)
/*任务错误代码：任务堆栈区域太小*/
/**
* @ingroup los_task
* Task error code: The task fails to be activated.
@ -315,7 +316,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_ACTIVE_FAILED LOS_ERRNO_OS_FATAL(LOS_MOD_TSK, 0x19)
/*任务错误代码：任务激活失败*/
/**
* @ingroup los_task
* Task error code: Too many task configuration items.
@ -326,7 +327,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_CONFIG_TOO_MANY LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x1a)
/*任务错误代码：任务配置项过多*/
/**
* @ingroup los_task
* Task error code: This error code is not in use temporarily.
@ -335,7 +336,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_CP_SAVE_AREA_NOT_ALIGN LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x1b)
/*任务错误代码：此错误代码暂时未使用*/
/**
* @ingroup los_task
* Task error code: This error code is not in use temporarily.
@ -344,7 +345,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_MSG_Q_TOO_MANY LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x1d)
/*任务错误代码：此错误代码暂时未使用*/
/**
* @ingroup los_task
* Task error code: This error code is not in use temporarily.
@ -353,7 +354,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_CP_SAVE_AREA_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x1e)
/*任务错误代码：此错误代码暂时未使用*/
/**
* @ingroup los_task
* Task error code: This error code is not in use temporarily.
@ -362,7 +363,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_SELF_DELETE_ERR LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x1f)
/*任务错误代码：此错误代码暂时未使用*/
/**
* @ingroup los_task
* Task error code: The task stack size is too large.
@ -372,7 +373,7 @@ extern "C" {
* Solution: shrink the task stack size parameter.
*/
#define LOS_ERRNO_TSK_STKSZ_TOO_LARGE LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x20)
/*任务错误代码：任务堆栈大小太大*/
/**
* @ingroup los_task
* Task error code: Suspending software timer task is not allowed.
@ -383,7 +384,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TSK_SUSPEND_SWTMR_NOT_ALLOWED LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x21)
/*任务错误代码：不允许挂起软件计时器任务*/
/**
* @ingroup los_task
* Task error code: The cpu affinity mask is incorrect.
@ -393,7 +394,7 @@ extern "C" {
* Solution: Please set the correct cpu affinity mask.
*/
#define LOS_ERRNO_TSK_CPU_AFFINITY_MASK_ERR LOS_ERRNO_OS_FATAL(LOS_MOD_TSK, 0x23)
/*任务错误代码：cpu关联掩码不正确*/
/**
* @ingroup los_task
* Task error code: Task yield in interrupt is not permited, which will result in an unexpected result.
@ -403,7 +404,7 @@ extern "C" {
* Solution: Don't call LOS_TaskYield in Interrupt.
*/
#define LOS_ERRNO_TSK_YIELD_IN_INT LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x24)
/*任务错误代码：不允许任务在中断中让步，这将导致意外结果*/
/**
* @ingroup los_task
* Task error code: Task sync resource (semaphore) allocated failed.
@ -413,7 +414,7 @@ extern "C" {
* Solution: Expand LOSCFG_BASE_IPC_SEM_LIMIT.
*/
#define LOS_ERRNO_TSK_MP_SYNC_RESOURCE LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x25)
/*任务错误代码：分配的任务同步资源（信号量）失败*/
/**
* @ingroup los_task
* Task error code: Task sync failed on operating running task across cores.
@ -423,7 +424,7 @@ extern "C" {
* Solution: Check task delete can be handled in user's scenario.
*/
#define LOS_ERRNO_TSK_MP_SYNC_FAILED LOS_ERRNO_OS_ERROR(LOS_MOD_TSK, 0x26)
/*任务错误代码：在操作跨核心运行的任务时，任务同步失败*/
/**
* @ingroup los_task
* Minimum stack size.
@ -432,7 +433,8 @@ extern "C" {
* LOS_TASK_MIN_STACK_SIZE bytes, aligned on a boundary of LOSCFG_STACK_POINT_ALIGN_SIZE.
*/
#define LOS_TASK_MIN_STACK_SIZE (ALIGN(KERNEL_TSK_MIN_STACK_SIZE, LOSCFG_STACK_POINT_ALIGN_SIZE))
/*这段代码是关于任务（task）的最小栈大小的定义通过这段代码，可以看出LOS_TASK_MIN_STACK_SIZE的大小是根据KERNEL_TSK_MIN_STACK_SIZE和
LOSCFG_STACK_POINT_ALIGN_SIZE来计算的并且保证了堆栈大小是按照一定的对齐方式进行分配的。*/
#ifdef LOSCFG_BASE_CORE_TSK_MONITOR
/**
* @ingroup los_task
@ -494,6 +496,9 @@ typedef VOID *(*TSK_ENTRY_FUNC)(UINTPTR param1,
UINTPTR param4);
#else
typedef VOID *(*TSK_ENTRY_FUNC)(VOID *param);
/*这段代码中使用了条件预处理指令#ifdef，它用于根据预定义的宏LOSOCFG_OBSOLETE_API是否存在来选择不同的类型定义,果LOSOCFG_OBSOLETE_API宏被定义，
则TSK_ENTRY_FUNC被定义为接受四个UINTPTR类型参数并返回VOID指针的函数指针类型；如果LOSOCFG_OBSOLETE_API宏未被定义，则TSK_ENTRY_FUNC被定义为接
受一个VOID指针参数并返回VOID指针的函数指针类型*/
#endif
/**
* @ingroup los_task
@ -519,7 +524,14 @@ typedef struct tagTskInitParam {
UINT32 uwResved; /**< Task is automatically deleted if uwResved is set to #LOS_TASK_STATUS_DETACHED.
Task will not be deleted automatically if it is set to 0. */
} TSK_INIT_PARAM_S;
/*这段代码定义了一个结构体类型TSK_INIT_PARAM_S，用于传递任务创建时的参数信息
pfnTaskEntry：任务入口函数指针。
usTaskPrio：任务优先级。
auwArgs/pArgs：任务参数，可以是一个指向参数列表的数组或一个指向参数结构体的指针，具体取决于LOSCFG_OBSOLETE_API是否被定义。
uwStackSize：任务栈大小。
pcName：任务名称。
usCpuAffiMask：CPU亲和性掩码，仅在LOSCFG_KERNEL_SMP被定义时有效。
uwResved：保留字段，如果设置为LOS_TASK_STATUS_DETACHED，则任务将自动删除。*/
/**
* @ingroup los_task
* Task name length
@ -551,7 +563,23 @@ typedef struct tagTskInfo {
BOOL bOvf; /**< Flag that indicates whether a task stack overflow
occurs or not */
} TSK_INFO_S;
/*这段代码定义了一个结构体类型TSK_INFO_S，用于保存任务的信息
TSK_INFO_S结构体包含以下成员：
acName：任务名称，长度为LOS_TASK_NAMELEN，默认值为32。
uwTaskID：任务ID。
usTaskStatus：任务状态。
usTaskPrio：任务优先级。
pTaskSem：信号量指针。
pTaskMux：互斥锁指针。
uwEvent：事件。
uwEventMask：事件掩码。
uwStackSize：任务栈大小。
uwTopOfStack：任务栈顶部。
uwBottomOfStack：任务栈底部。
uwSP：任务SP指针。
uwCurrUsed：当前任务栈使用量。
uwPeakUsed：任务栈使用峰值。
bOvf：表示任务栈是否发生溢出的标志。*/
#ifdef LOSCFG_TASK_STATIC_ALLOCATION
/**
* @ingroup los_task
@ -601,7 +629,24 @@ typedef struct tagTskInfo {
* @since Huawei LiteOS V200R005C10
*/
extern UINT32 LOS_TaskCreateOnlyStatic(UINT32 *taskId, TSK_INIT_PARAM_S *initParam, VOID *topStack);
/*该函数的作用是创建一个静态分配的任务，并将其挂起。静态分配任务的栈空间由用户自行分配和释放，需要在删除任务时及时释放栈空间。
函数的参数如下：
taskId：[OUT] 任务ID，类型为UINT32指针。
initParam：[IN] 任务创建的参数，类型为TSK_INIT_PARAM_S结构体指针。
topStack：[IN] 任务栈的顶部地址，类型为VOID指针。
函数的返回值为操作结果，可能的返回值如下：
LOS_ERRNO_TSK_ID_INVALID：无效的任务ID，taskId参数为NULL。
LOS_ERRNO_TSK_PTR_NULL：initParam参数为NULL。
LOS_ERRNO_TSK_NAME_EMPTY：任务名称为NULL。
LOS_ERRNO_TSK_ENTRY_NULL：任务执行函数为NULL。
LOS_ERRNO_TSK_PRIOR_ERROR：任务优先级错误。
LOS_ERRNO_TSK_STKSZ_TOO_LARGE：任务栈大小太大。
LOS_ERRNO_TSK_STKSZ_TOO_SMALL：任务栈大小太小。
LOS_ERRNO_TSK_TCB_UNAVAILABLE：没有可用的任务控制块。
LOS_ERRNO_TSK_NO_MEMORY：任务创建时内存不足。
LOS_OK：任务成功创建。*/
/**
* @ingroup los_task
* @brief Create a task.
@ -653,7 +698,9 @@ extern UINT32 LOS_TaskCreateOnlyStatic(UINT32 *taskId, TSK_INIT_PARAM_S *initPar
*/
extern UINT32 LOS_TaskCreateStatic(UINT32 *taskId, TSK_INIT_PARAM_S *initParam, VOID *topStack);
#endif
/*这段代码是关于任务创建的函数LOS_TaskCreateStatic的声明。
函数的功能是创建一个任务并将其挂起。如果系统初始化后创建的任务的优先级高于当前任务并且任务调度未被锁定，则会调度该任务运行.静态分配任务的栈空间由用户自行分配和释放，需要在删除任务时及时释放栈空间。
该函数的调用需要传入任务ID、任务创建参数和任务栈的顶部地址，返回创建结果*/
/**
* @ingroup los_task
* @brief Create a task and suspend.
@ -699,7 +746,9 @@ extern UINT32 LOS_TaskCreateStatic(UINT32 *taskId, TSK_INIT_PARAM_S *initParam,
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskCreateOnly(UINT32 *taskId, TSK_INIT_PARAM_S *initParam);
/*这段代码是关于任务创建的函数LOS_TaskCreateOnly的声明。
函数的功能是创建一个任务并将其挂起。在任务创建后，该任务不会被添加到就绪任务队列中。*/
/**
* @ingroup los_task
* @brief Create a task.
@ -745,7 +794,7 @@ extern UINT32 LOS_TaskCreateOnly(UINT32 *taskId, TSK_INIT_PARAM_S *initParam);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskCreate(UINT32 *taskId, TSK_INIT_PARAM_S *initParam);
/*该函数的功能是创建一个任务。如果在系统初始化之后创建的任务的优先级比当前任务高并且任务调度未被锁定，则将其调度运行。如果不是，则创建的任务将添加到就绪任务队列中*/
/**
* @ingroup los_task
* @brief Resume a task.
@ -772,7 +821,9 @@ extern UINT32 LOS_TaskCreate(UINT32 *taskId, TSK_INIT_PARAM_S *initParam);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskResume(UINT32 taskId);
/*这是华为LiteOS中用于恢复（Resume）任务的函数LOS_TaskResume的声明。
该函数的功能是恢复一个被挂起（Suspended）的任务。*/
/**
* @ingroup los_task
* @brief Suspend a task.
@ -802,7 +853,9 @@ extern UINT32 LOS_TaskResume(UINT32 taskId);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskSuspend(UINT32 taskId);
/*这是华为LiteOS中用于挂起（Suspend）任务的函数LOS_TaskSuspend的声明。
该函数的功能是挂起指定的任务，并将其从就绪任务队列中移除。*/
/**
* @ingroup los_task
* @brief Delete a task.
@ -833,7 +886,9 @@ extern UINT32 LOS_TaskSuspend(UINT32 taskId);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskDelete(UINT32 taskId);
/*这是华为LiteOS中用于删除任务的函数LOS_TaskDelete的声明。
该函数的功能是删除指定的任务并释放其任务栈和任务控制块的资源。*/
/**
* @ingroup los_task
* @brief Delay a task.
@ -867,7 +922,9 @@ extern UINT32 LOS_TaskDelete(UINT32 taskId);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskDelay(UINT32 tick);
/*这是华为LiteOS中用于延迟（Delay）任务的函数LOS_TaskDelay的声明。
该函数的功能是延迟当前任务的执行。在延迟了指定数量的Ticks后，任务可以被调度到就绪任务队列中。*/
/**
* @ingroup los_task
* @brief Lock the task scheduling.
@ -891,7 +948,9 @@ extern UINT32 LOS_TaskDelay(UINT32 tick);
* @since Huawei LiteOS V100R001C00
*/
extern VOID LOS_TaskLock(VOID);
/*这是华为LiteOS中用于锁定任务调度的函数LOS_TaskLock的声明。
该函数的功能是锁定任务调度。如果任务调度被锁定，则不会发生任务切换。*/
/**
* @ingroup los_task
* @brief Unlock the task scheduling.
@ -913,7 +972,9 @@ extern VOID LOS_TaskLock(VOID);
* @since Huawei LiteOS V100R001C00
*/
extern VOID LOS_TaskUnlock(VOID);
/*这是华为LiteOS中用于解锁任务调度的函数LOS_TaskUnlock的声明。
该函数的功能是解锁任务调度。调用此API将减少任务锁的数量。如果一个任务被锁定多次，则只有在锁的数量变为零时才会解锁任务调度*/
/**
* @ingroup los_task
* @brief Set a task priority.
@ -946,7 +1007,9 @@ extern VOID LOS_TaskUnlock(VOID);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskPriSet(UINT32 taskId, UINT16 taskPrio);
/*这是华为LiteOS中用于设置任务优先级的函数LOS_TaskPriSet的声明。
该函数的功能是设置指定任务的优先级*/
/**
* @ingroup los_task
* @brief Set the priority of the current running task to a specified priority.
@ -976,7 +1039,9 @@ extern UINT32 LOS_TaskPriSet(UINT32 taskId, UINT16 taskPrio);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_CurTaskPriSet(UINT16 taskPrio);
/*这是华为LiteOS中用于将当前运行任务的优先级设置为指定优先级的函数LOS_CurTaskPriSet的声明。
该函数的功能是将当前运行任务的优先级设置为指定的优先级。*/
/**
* @ingroup los_task
* @brief Change the scheduling sequence of tasks with the same priority.
@ -1002,7 +1067,9 @@ extern UINT32 LOS_CurTaskPriSet(UINT16 taskPrio);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskYield(VOID);
/*这是华为LiteOS中用于改变具有相同优先级的任务调度顺序的函数LOS_TaskYield的声明。
该函数的功能是将当前任务移动到具有相同优先级的就绪任务队列的队尾。*/
/**
* @ingroup los_task
* @brief Obtain a task priority.
@ -1022,7 +1089,9 @@ extern UINT32 LOS_TaskYield(VOID);
* @since Huawei LiteOS V100R001C00
*/
extern UINT16 LOS_TaskPriGet(UINT32 taskId);
/*这是华为LiteOS中获取指定任务优先级的函数LOS_TaskPriGet的声明。
该函数的功能是获取指定任务的优先级。*/
/**
* @ingroup los_task
* @brief Obtain current running task ID.
@ -1040,7 +1109,9 @@ extern UINT16 LOS_TaskPriGet(UINT32 taskId);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_CurTaskIDGet(VOID);
/*这是华为LiteOS中获取当前正在运行的任务ID的函数LOS_CurTaskIDGet的声明。
该函数的功能是获取当前正在运行的任务的ID。*/
/**
* @ingroup los_task
* @brief Obtain a task information structure.
@ -1064,7 +1135,9 @@ extern UINT32 LOS_CurTaskIDGet(VOID);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_TaskInfoGet(UINT32 taskId, TSK_INFO_S *taskInfo);
/*这是华为LiteOS中获取任务信息结构的函数LOS_TaskInfoGet的声明。
该函数的功能是获取一个任务信息结构。*/
/**
* @ingroup los_task
* @brief Set the affinity mask of the task scheduling cpu.
@ -1090,7 +1163,9 @@ extern UINT32 LOS_TaskInfoGet(UINT32 taskId, TSK_INFO_S *taskInfo);
* @since Huawei LiteOS V200R003C00
*/
extern UINT32 LOS_TaskCpuAffiSet(UINT32 taskId, UINT16 usCpuAffiMask);
/*这是华为LiteOS中设置任务调度CPU亲和性掩码的函数LOS_TaskCpuAffiSet的声明。
该函数的功能是设置任务调度CPU亲和性掩码，即指定任务允许运行在哪些CPU核心上*/
/**
* @ingroup los_task
* @brief Get the affinity mask of the task scheduling cpu.
@ -1110,7 +1185,9 @@ extern UINT32 LOS_TaskCpuAffiSet(UINT32 taskId, UINT16 usCpuAffiMask);
* @since Huawei LiteOS V200R003C00
*/
extern UINT16 LOS_TaskCpuAffiGet(UINT32 taskId);
/*这是华为LiteOS中获取任务调度CPU亲和性掩码的函数LOS_TaskCpuAffiGet的声明。
该函数的功能是获取任务调度CPU的亲和性掩码，即获取指定任务允许运行在哪些CPU核心上*/
/**
* @ingroup los_task
* @brief Recycle task stack resource.
@ -1129,7 +1206,10 @@ extern UINT16 LOS_TaskCpuAffiGet(UINT32 taskId);
* @since Huawei LiteOS V200R003C00
*/
extern VOID LOS_TaskResRecycle(VOID);
/*这是华为LiteOS中回收任务堆栈资源的函数LOS_TaskResRecycle的声明。
该函数的功能是回收已经被删除的任务的堆栈资源。当任务被删除时，它的堆栈内存块不会立即释放，而是留给后续新创建的任务使用。但如果一段时间后没有新任务创建，
则这些堆栈内存块会浪费系统资源，应该通过调用此函数进行回收*/
#ifdef LOSCFG_OBSOLETE_API
#define LOS_TASK_PARAM_INIT_ARG_0(initParam, arg) \
initParam.auwArgs[0] = (UINTPTR)arg
@ -1138,7 +1218,7 @@ extern VOID LOS_TaskResRecycle(VOID);
#define LOS_TASK_PARAM_INIT_ARG(initParam, arg) \
initParam.pArgs = (VOID *)arg
#endif
/*这段代码是关于任务参数初始化宏的定义*/
/**
* @ingroup los_task
* @brief Define the lowpower framework process function type.
@ -1157,7 +1237,7 @@ extern VOID LOS_TaskResRecycle(VOID);
* @since Huawei LiteOS V200R005C10
*/
typedef VOID (*LOWPOWERIDLEHOOK)(VOID);
/*这段代码定义了一个函数指针类型LOWPOWERIDLEHOOK，用于定义低功耗框架的处理函数*/
/**
* @ingroup los_task
* @brief Register a hook to enter lowpower framework process.
@ -1176,7 +1256,9 @@ typedef VOID (*LOWPOWERIDLEHOOK)(VOID);
* @since Huawei LiteOS V200R005C10
*/
extern VOID LOS_LowpowerHookReg(LOWPOWERIDLEHOOK hook);
/*这段代码是关于注册低功耗处理函数的函数LOS_LowpowerHookReg的声明。
该函数的功能是向系统注册一个用于处理低功耗操作的函数。此函数将会在系统进入低功耗模式时被调用，以执行特定的低功耗操作或处理*/
/**
* @ingroup los_task
* @brief Define the type of idle handler hook function.
@ -1193,7 +1275,11 @@ extern VOID LOS_LowpowerHookReg(LOWPOWERIDLEHOOK hook);
* @since Huawei LiteOS V200R005C20
*/
typedef VOID (*IDLEHANDLERHOOK)(VOID);
/*这段代码定义了一个函数指针类型IDLEHANDLERHOOK，用于定义空闲处理函数的类型。
该函数指针类型的函数原型为VOID (*IDLEHANDLERHOOK)(VOID)，表示该函数没有任何参数，也没有返回值。
在系统空闲状态时，可以使用IDLEHANDLERHOOK类型的函数指针来定义一个空闲处理函数。这个处理函数会在系统处于空闲状态时被调用，可以用于执行一些特定的任务或操作*/
/**
* @ingroup los_task
* @brief Register the hook function for idle task.
@ -1212,7 +1298,9 @@ typedef VOID (*IDLEHANDLERHOOK)(VOID);
* @since Huawei LiteOS V200R005C20
*/
extern VOID LOS_IdleHandlerHookReg(IDLEHANDLERHOOK hook);
/*这段代码是关于注册空闲处理函数的函数LOS_IdleHandlerHookReg的声明。
该函数的功能是向系统注册一个用于处理空闲状态的函数。此函数将会在系统进入空闲状态时被调用，以执行特定的任务或操作*/
#ifdef __cplusplus
#if __cplusplus
}

51
src/kernel/include/los_tick.h
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.
* --------------------------------------------------------------------------- */
/*这些代码主要用于系统计时、延时和低功耗唤醒功能，提供了丰富的 Tick 相关操作接口和功能*/
/**
* @defgroup los_tick Tick
* @ingroup kernel
@ -49,37 +49,37 @@ extern "C" {
* Number of milliseconds in one second.
*/
#define OS_SYS_MS_PER_SECOND 1000
/*一秒钟内的毫秒数。*/
/**
* @ingroup los_tick
* Number of microseconds in one second.
*/
#define OS_SYS_US_PER_SECOND 1000000
/*一秒钟内的微秒数*/
/**
* @ingroup los_tick
* Number of nanoseconds in one second.
*/
#define OS_SYS_NS_PER_SECOND 1000000000
/*1秒内的纳秒数*/
/**
* @ingroup los_tick
* Number of microseconds in one milliseconds.
*/
#define OS_SYS_US_PER_MS 1000
/*一毫秒中的微秒数*/
/**
* @ingroup los_tick
* Number of nanoseconds in one milliseconds.
*/
#define OS_SYS_NS_PER_MS 1000000
/*一毫秒中的纳秒数*/
/**
* @ingroup los_tick
* Number of nanoseconds in one microsecond.
*/
#define OS_SYS_NS_PER_US 1000
/*一微秒中的纳秒数*/
/**
* @ingroup los_tick
* Tick error code: The Tick configuration is incorrect.
@ -90,7 +90,7 @@ extern "C" {
* in los_config.h.
*/
#define LOS_ERRNO_TICK_CFG_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_TICK, 0x00)
/*Tick错误代码：Tick配置不正确*/
/**
* @ingroup los_tick
* Tick error code: This error code is not in use temporarily.
@ -99,7 +99,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TICK_NO_HWTIMER LOS_ERRNO_OS_ERROR(LOS_MOD_TICK, 0x01)
/*Tick错误代码：此错误代码暂时未使用*/
/**
* @ingroup los_tick
* Tick error code: This error code is not in use temporarily.
@ -108,31 +108,31 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0.
*/
#define LOS_ERRNO_TICK_PER_SEC_TOO_SMALL LOS_ERRNO_OS_ERROR(LOS_MOD_TICK, 0x02)
/*Tick错误代码：此错误代码暂时未使用。*/
/**
* @ingroup los_config
* system clock
*/
extern UINT32 g_sysClock;
/*这段代码定义了一个名为g_sysClock的全局变量，它表示系统时钟。没有进行定义*/
/**
* @ingroup los_config
* get system clock
*/
#define GET_SYS_CLOCK() (g_sysClock)
/*这段代码定义了一个宏，用于获取系统时钟的值*/
/**
* @ingroup los_config
* set system clock
*/
#define SET_SYS_CLOCK(clock) (g_sysClock = (clock))
/*这段代码定义了一个宏，用于设置系统时钟的值*/
/**
* @ingroup los_config
* ticks per second
*/
extern UINT32 g_tickPerSecond;
/*这段代码定义了一个名为g_tickPerSecond的全局变量，它表示每秒钟的时钟滴答数（ticks per second）*/
/**
* @ingroup los_tick
* system time structure.
@ -146,7 +146,7 @@ typedef struct tagSysTime {
UINT8 ucSecond; /**< second, the value range is 0 - 59 */
UINT8 ucWeek; /**< week, the value range is 0 - 6 */
} SYS_TIME_S;
/*这段代码定义了一个名为tagSysTime的结构体，它表示系统时间信息。*/
/**
* @ingroup los_tick
* @brief Obtain the number of Ticks.
@ -165,7 +165,9 @@ typedef struct tagSysTime {
* @since Huawei LiteOS V100R001C00
*/
extern UINT64 LOS_TickCountGet(VOID);
/*这段代码声明了一个函数LOS_TickCountGet，用于获取自系统启动以来的Tick数。
函数的功能是获取自系统启动以来经过的Tick数，即系统已经运行的时间。它返回一个UINT64类型的值表示Tick数*/
/**
* @ingroup los_tick
* @brief Obtain the number of cycles in one tick.
@ -183,7 +185,9 @@ extern UINT64 LOS_TickCountGet(VOID);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_CyclePerTickGet(VOID);
/*这段代码声明了一个函数LOS_CyclePerTickGet，用于获取一个Tick中的周期数。
函数的功能是获取一个Tick中的CPU周期数。它返回一个UINT32类型的值，表示一个Tick中的周期数*/
/**
* @ingroup los_tick
* @brief Convert Ticks to milliseconds.
@ -208,7 +212,9 @@ extern UINT32 LOS_CyclePerTickGet(VOID);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_Tick2MS(UINT32 tick);
/*这段代码声明了一个函数LOS_Tick2MS，用于将Ticks转换为毫秒数。
该函数的功能是将Ticks转换为相应的毫秒数值。参数tick表示待转换的Ticks数，返回值为UINT32类型的毫秒数。*/
/**
* @ingroup los_tick
* @brief Convert milliseconds to Ticks.
@ -234,7 +240,9 @@ extern UINT32 LOS_Tick2MS(UINT32 tick);
* @since Huawei LiteOS V100R001C00
*/
extern UINT32 LOS_MS2Tick(UINT32 millisec);
/*这段代码声明了一个函数LOS_MS2Tick，用于将毫秒数转换为Ticks。
该函数的功能是将毫秒数转换为相应的Ticks数值。参数millisec表示待转换的毫秒数，返回值为UINT32类型的Ticks数*/
/**
* @ingroup los_tick
* @brief Obtain system cycle count.
@ -260,7 +268,9 @@ extern UINT32 LOS_MS2Tick(UINT32 millisec);
* @since Huawei LiteOS V100R001C00
*/
extern VOID LOS_GetCpuCycle(UINT32 *puwCntHi, UINT32 *puwCntLo);
/*这段代码声明了一个函数LOS_GetCpuCycle，用于获取系统启动以来的CPU周期计数。
该函数的功能是获取系统自启动以来的CPU周期计数。参数puwCntHi和puwCntLo是指向UINT32类型的指针，用于存储CPU周期计数的高32位和低32位。*/
/**
* @ingroup los_tick
* @brief Obtain system time in nanoseconds.
@ -279,7 +289,9 @@ extern VOID LOS_GetCpuCycle(UINT32 *puwCntHi, UINT32 *puwCntLo);
* @since Huawei LiteOS V100R001C00
*/
extern UINT64 LOS_CurrNanosec(VOID);
/*这段代码声明了一个函数LOS_CurrNanosec，用于获取系统当前的纳秒级时间。
该函数的功能是获取系统当前的时间，单位为纳秒（nanoseconds）*/
/**
* @ingroup los_tick
* @brief spinning-delay in microsecond (us).
@ -299,7 +311,7 @@ extern UINT64 LOS_CurrNanosec(VOID);
* @since Huawei LiteOS V100R001C00
*/
extern VOID LOS_Udelay(UINT32 usecs);
/*这段代码声明了一个函数LOS_Udelay，用于进行微秒级的自旋延迟。*/
/**
* @ingroup los_tick
* @brief spinning-delay in millisecond (ms).
@ -319,7 +331,7 @@ extern VOID LOS_Udelay(UINT32 usecs);
* @since Huawei LiteOS V100R001C00
*/
extern VOID LOS_Mdelay(UINT32 msecs);
/*这段代码声明了一个函数LOS_Mdelay，用于进行毫秒级的自旋延迟。*/
#ifdef LOSCFG_KERNEL_TICKLESS
/**
* @ingroup los_tick
@ -340,6 +352,8 @@ extern VOID LOS_Mdelay(UINT32 msecs);
*/
typedef VOID (*WAKEUPTICKHOOK)(UINT32 tickNum);
/*这段代码定义了一个函数指针类型WAKEUPTICKHOOK，用于定义低功耗框架的唤醒函数。
定义该函数指针类型是为了在实现低功耗功能时，可以根据实际情况定义自己的唤醒函数，用于在系统进入低功耗模式后，当有外部事件需要唤醒系统时调用该函数*/
/**
* @ingroup los_tick
* @brief Register a hook to wakeup from tick interrupt.
@ -358,6 +372,9 @@ typedef VOID (*WAKEUPTICKHOOK)(UINT32 tickNum);
* @since Huawei LiteOS V200R005C10
*/
extern VOID LOS_IntTickWakeupHookReg(WAKEUPTICKHOOK hook);
/*这段代码声明了一个函数LOS_IntTickWakeupHookReg，用于注册一个从tick中断唤醒后的回调函数。
LOS_IntTickWakeupHookReg函数的功能是在系统从tick中断唤醒后注册一个恢复函数，用于在系统唤醒后执行一些特定的操作*/
#endif
#ifdef __cplusplus

5
src/kernel/include/los_tickless.h
Unescape View File

@ -26,6 +26,7 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */
/*这些代码主要用于开启和关闭 Tickless 模式，提供了 Tickless 相关操作接口和功能。*/
/**
* @defgroup los_tickless Tickless
* @ingroup kernel
@ -62,7 +63,9 @@ extern "C" {
* @since Huawei LiteOS V200R001C00
*/
extern VOID LOS_TicklessEnable(VOID);
/*这段代码声明了一个函数LOS_TicklessEnable，用于启用tickless模式。
LOS_TicklessEnable函数的功能是启用tickless模式。在这种模式下，系统从周期性时钟模式切换到动态时钟模式，能够有效地减少系统的功耗*/
/**
* @ingroup los_tickless
* @brief disable the tickless mode.
@ -83,7 +86,9 @@ extern VOID LOS_TicklessEnable(VOID);
* @since Huawei LiteOS V200R001C00
*/
extern VOID LOS_TicklessDisable(VOID);
/*这段代码声明了一个函数LOS_TicklessDisable，用于禁用tickless模式。
LOS_TicklessDisable函数的功能是禁用tickless模式。在这种模式下，系统从动态时钟模式切换回周期性时钟模式，系统将会以固定的时间间隔来产生时钟中断。*/
#ifdef __cplusplus
#if __cplusplus
}

31
src/kernel/include/los_toolchain.h
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.
* --------------------------------------------------------------------------- */
/*这段代码提供了一些通用的宏和函数，可以帮助开发者在不同的编译环境下编写跨平台的代码，并提供了一些位操作的便利功能。*/
/**
* @defgroup los_toolchain
* @ingroup kernel
@ -69,7 +69,15 @@ extern "C" {
#ifndef CLZ
#define CLZ(value) (__clz(value))
#endif
/*这段代码是宏定义，用于在 ARM Compiler 下定义一些与编译器相关的宏和函数。
ASM 宏定义了一个 __asm 关键字，用于在 C 语言中嵌入汇编代码。
INLINE 宏定义了一个 __inline 关键字，用于将函数声明为内联函数。
STATIC_INLINE 宏定义了一个 static __inline 关键字组合，用于将函数声明为静态内联函数。
USED 宏使用了 GCC 的 __attribute__((used)) 属性，用于告诉编译器某个变量或函数可能会被其他地方使用，即使看起来没有被引用。
WEAK 宏使用了 GCC 的 __attribute__((weak)) 属性，用于声明一个弱符号（weak symbol），表示该符号可以被覆盖。
CLZ 宏定义了一个函数，用于计算一个数的二进制表示中前导零的位数。它使用了编译器自带的 __clz 内置函数。
这些宏的定义是针对 IAR Compiler 编译器的，可以帮助代码在不同的编译环境中正确地进行编译和链接*/
/* for IAR Compiler */
#elif defined ( __ICCARM__ )
@ -100,7 +108,16 @@ extern "C" {
#ifndef CTZ
#define CTZ(value) (__UNDEFINED(value))
#endif
/*这段代码是宏定义，用于在 IAR Compiler 下定义一些与编译器相关的宏和函数。
ASM 宏定义了一个 __asm 关键字，用于在 C 语言中嵌入汇编代码。
INLINE 宏定义了一个 inline 关键字，用于将函数声明为内联函数。
STATIC_INLINE 宏定义了一个 static inline 关键字组合，用于将函数声明为静态内联函数。
USED 宏使用了 IAR Compiler 的 __root 属性，用于告诉编译器某个变量或函数可能会被其他地方使用，即使看起来没有被引用。
WEAK 宏使用了 IAR Compiler 的 __weak 属性，用于声明一个弱符号（weak symbol），表示该符号可以被覆盖。
CLZ 宏定义了一个函数，用于计算一个数的二进制表示中前导零的位数。它使用了 IAR Compiler 提供的 __iar_builtin_CLZ 内置函数。
CTZ 宏定义了一个函数，用于计算一个数的二进制表示中末尾零的位数。它使用了一个未定义的函数 __UNDEFINED。
这些宏的定义是针对 IAR Compiler 编译器的，可以帮助代码在不同的编译环境中正确地进行编译和链接。*/
/* for GNU Compiler */
#elif defined ( __GNUC__ )
@ -135,7 +152,17 @@ extern "C" {
#ifndef FFS
#define FFS(value) (__builtin_ffs(value))
#endif
/*这段代码是宏定义，用于在 GNU Compiler 下定义一些与编译器相关的宏和函数。
ASM 宏定义了一个 __asm 关键字，用于在 C 语言中嵌入汇编代码。
INLINE 宏定义了一个 __inline 关键字，用于将函数声明为内联函数。
STATIC_INLINE 宏定义了一个 static inline 关键字组合，用于将函数声明为静态内联函数。
USED 宏使用了 GNU Compiler 的 __attribute__((used)) 属性，用于告诉编译器某个变量或函数可能会被其他地方使用，即使看起来没有被引用。
WEAK 宏使用了 GNU Compiler 的 __attribute__((weak)) 属性，用于声明一个弱符号（weak symbol），表示该符号可以被覆盖。
CLZ 宏定义了一个函数，用于计算一个数的二进制表示中前导零的位数。它使用了 GNU Compiler 提供的 __builtin_clz 内置函数。
CTZ 宏定义了一个函数，用于计算一个数的二进制表示中末尾零的位数。它使用了 GNU Compiler 提供的 __builtin_ctz 内置函数。
FFS 宏定义了一个函数，用于计算一个数的二进制表示中最低位（从右往左）的非零位的位置。它使用了 GNU Compiler 提供的 __builtin_ffs 内置函数。
这些宏的定义是针对 GNU Compiler 编译器的，可以帮助代码在不同的编译环境中正确地进行编译和链接。*/
#else
#error Unknown compiler.
#endif

187
src/kernel/include/los_trace.h
Unescape View File

@ -25,7 +25,8 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */
/*这段代码是关于 Huawei LiteOS 操作系统中的跟踪（Trace）功能的实现，包括了跟踪数据结构、跟踪事件类型、初始化、启动、停止、事件掩码
设置以及导出等一系列相关操作。此外，还定义了一些宏，用于用户自定义的跟踪代码存根，以简单地追踪事件。*/
/**
* @defgroup los_trace Trace
* @ingroup kernel
@ -49,25 +50,25 @@ extern "C" {
/**
* @ingroup los_trace
* Trace Control agent task's priority.
* Trace Control agent task's priori00ty.
*/
#define LOSCFG_TRACE_TASK_PRIORITY 2
#endif
#define LOSCFG_TRACE_OBJ_MAX_NAME_SIZE LOS_TASK_NAMELEN
/*这段代码是关于轨迹追踪（Trace Control）的配置*/
/**
* @ingroup los_trace
* Trace records the max number of objects(kernel object, like tasks). if set to 0, trace will not record any object.
*/
#define LOSCFG_TRACE_OBJ_MAX_NUM 0 // LOSCFG_BASE_CORE_TSK_LIMIT
/*这段代码是关于轨迹追踪（Trace Control）中记录对象数量的配置*/
/**
* @ingroup los_trace
* Trace tlv encode buffer size, the buffer is used to encode one piece raw frame to tlv message in online mode.
*/
#define LOSCFG_TRACE_TLV_BUF_SIZE 100
/*这段代码是关于轨迹追踪（Trace Control）中tlv编码缓冲区大小的配置*/
/**
* @ingroup los_trace
* Trace error code: init trace failed.
@ -77,7 +78,7 @@ extern "C" {
* Solution: Follow the trace State Machine.
*/
#define LOS_ERRNO_TRACE_ERROR_STATUS LOS_ERRNO_OS_ERROR(LOS_MOD_TRACE, 0x00)
/*跟踪错误代码：初始化跟踪失败*/
/**
* @ingroup los_trace
* Trace error code: Insufficient memory for trace buf init.
@ -87,7 +88,7 @@ extern "C" {
* Solution: Expand the configured system memory or decrease the value defined by LOS_TRACE_BUFFER_SIZE.
*/
#define LOS_ERRNO_TRACE_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_TRACE, 0x01)
/*跟踪错误代码：内存不足，无法进行跟踪buf-init。*/
/**
* @ingroup los_trace
* Trace error code: Insufficient memory for trace struct.
@ -97,7 +98,7 @@ extern "C" {
* Solution: Increase trace buffer's size.
*/
#define LOS_ERRNO_TRACE_BUF_TOO_SMALL LOS_ERRNO_OS_ERROR(LOS_MOD_TRACE, 0x02)
/*跟踪错误代码：跟踪结构的内存不足 */
/**
* @ingroup los_trace
* Trace state.
@ -108,7 +109,12 @@ enum TraceState {
TRACE_STARTED, /**< trace is started and system is tracing */
TRACE_STOPED, /**< trace is stopped */
};
/*这段代码定义了一个枚举类型 TraceState，用于表示轨迹追踪（Trace Control）的状态。该枚举包括以下几个取值：
TRACE_UNINIT：表示轨迹追踪未初始化。
TRACE_INITED：表示轨迹追踪已经初始化，但尚未启动。
TRACE_STARTED：表示轨迹追踪已经启动，系统正在进行追踪。
TRACE_STOPED：表示轨迹追踪已经停止。*/
/**
* @ingroup los_trace
* Trace mask is used to filter events in runtime. Each mask keep only one unique bit to 1, and user can define own
@ -128,7 +134,20 @@ typedef enum {
TRACE_MAX_FLAG = 0x80000000,
TRACE_USER_DEFAULT_FLAG = 0xFFFFFFF0,
} LOS_TRACE_MASK;
/*这段代码定义了一个枚举类型 LOS_TRACE_MASK，用于在运行时过滤事件。每个标志位都保持唯一的一位为1，用户可以定义自己模块的跟踪掩码
该枚举包括了以下几个取值：
TRACE_SYS_FLAG：系统事件的跟踪掩码
TRACE_HWI_FLAG：硬件中断事件的跟踪掩码
TRACE_TASK_FLAG：任务事件的跟踪掩码
TRACE_SWTMR_FLAG：软件定时器事件的跟踪掩码
TRACE_MEM_FLAG：内存事件的跟踪掩码
TRACE_QUE_FLAG：队列事件的跟踪掩码
TRACE_EVENT_FLAG：事件事件的跟踪掩码
TRACE_SEM_FLAG：信号量事件的跟踪掩码
TRACE_MUX_FLAG：互斥锁事件的跟踪掩码
TRACE_MAX_FLAG：最大的跟踪掩码
TRACE_USER_DEFAULT_FLAG：用户默认的跟踪掩码*/
/**
* @ingroup los_trace
* Trace event type which indicate the exactly happend events, user can define own module's event type like
@ -208,7 +227,10 @@ typedef enum {
MUX_PEND = TRACE_MUX_FLAG | 2,
MUX_POST = TRACE_MUX_FLAG | 3,
} LOS_TRACE_TYPE;
/*这段代码定义了一个枚举类型 LOS_TRACE_TYPE，用于表示不同的追踪事件类型。每个事件类型都由一个唯一的标志位组成，用户可以根据需要定义自己模块的事件类型。
该枚举类型包括了各种事件类型，如系统事件、硬件中断事件、任务事件、软件定时器事件、内存事件、队列事件、事件事件、信号量事件和互斥锁事件等。
每个事件类型都使用了特定的跟踪掩码，以便在运行时进行事件过滤和分析。
通过定义自己模块的事件类型，用户可以灵活地追踪和记录特定模块的事件，以便进行调试和性能分析*/
/**
* @ingroup los_trace
* struct to store the trace config information.
@ -218,7 +240,7 @@ typedef struct {
UINT32 clockFreq; /**< system clock frequency */
UINT32 version; /**< trace version */
} TraceBaseHeaderInfo;
/*这段代码是一个注释和结构体的定义，用于存储跟踪配置信息。*/
/**
* @ingroup los_trace
* struct to store the event infomation
@ -246,7 +268,7 @@ typedef struct {
UINTPTR params[LOSCFG_TRACE_FRAME_MAX_PARAMS]; /**< event frame's params */
#endif
} TraceEventFrame;
/*这段代码是一个注释和结构体的定义，用于存储事件信息*/
/**
* @ingroup los_trace
* struct to store the kernel obj information, we defined task as kernel obj in this system.
@ -256,7 +278,7 @@ typedef struct {
UINT32 prio; /**< kernel obj's priority */
CHAR name[LOSCFG_TRACE_OBJ_MAX_NAME_SIZE]; /**< kernel obj's name */
} ObjData;
/*这段代码是一个注释和结构体的定义，用于存储内核对象信息*/
/**
* @ingroup los_trace
* struct to store the trace data.
@ -269,7 +291,7 @@ typedef struct {
UINT16 objOffset; /**< the offset of the first obj data to record beginning */
UINT16 frameOffset; /**< the offset of the first event frame data to record beginning */
} OfflineHead;
/*这段代码是一个注释和结构体的定义，用于存储跟踪数据。*/
/**
* @ingroup los_trace
* @brief Define the type of trace hardware interrupt filter hook function.
@ -293,7 +315,7 @@ typedef BOOL (*TRACE_HWI_FILTER_HOOK)(UINT32 hwiNum);
typedef VOID (*TRACE_EVENT_HOOK)(UINT32 eventType, UINTPTR identity, const UINTPTR *params, UINT16 paramCount);
extern TRACE_EVENT_HOOK g_traceEventHook;
/*这段代码定义了两个函数指针类型和一个函数指针变量，这些函数指针类型和变量用于实现 Huawei LiteOS 操作系统的事件跟踪功能。*/
/**
* @ingroup los_trace
* Trace event params:
@ -312,64 +334,64 @@ extern TRACE_EVENT_HOOK g_traceEventHook;
* eg. Trace only you need parmas as:
* #define TASK_PRIOSET_PARAMS(taskId, taskStatus, oldPrio, newPrio) taskId
*/
#define TASK_SWITCH_PARAMS(taskId, oldPriority, oldTaskStatus, newPriority, newTaskStatus) \
#define TASK_SWITCH_PARAMS(taskId, oldPriority, oldTaskStatus, newPriority, newTaskStatus) \/*这段代码是一个宏定义，用于定义任务切换所需的参数集合*/
taskId, oldPriority, oldTaskStatus, newPriority, newTaskStatus
#define TASK_PRIOSET_PARAMS(taskId, taskStatus, oldPrio, newPrio) taskId, taskStatus, oldPrio, newPrio
#define TASK_CREATE_PARAMS(taskId, taskStatus, prio) taskId, taskStatus, prio
#define TASK_DELETE_PARAMS(taskId, taskStatus, usrStack) taskId, taskStatus, usrStack
#define TASK_SUSPEND_PARAMS(taskId, taskStatus, runTaskId) taskId, taskStatus, runTaskId
#define TASK_RESUME_PARAMS(taskId, taskStatus, prio) taskId, taskStatus, prio
#define TASK_SIGNAL_PARAMS(taskId, signal, schedFlag) // taskId, signal, schedFlag
#define SWTMR_START_PARAMS(swtmrId, mode, overrun, interval, expiry) swtmrId, mode, overrun, interval, expiry
#define SWTMR_DELETE_PARAMS(swtmrId) swtmrId
#define SWTMR_EXPIRED_PARAMS(swtmrId) swtmrId
#define SWTMR_STOP_PARAMS(swtmrId) swtmrId
#define TASK_PRIOSET_PARAMS(taskId, taskStatus, oldPrio, newPrio) taskId, taskStatus, oldPrio, newPrio/*这段代码是一个宏定义，用于定义任务优先级设置所需的参数集合*/
#define TASK_CREATE_PARAMS(taskId, taskStatus, prio) taskId, taskStatus, prio/*这段代码是一个宏定义，用于定义任务创建所需的参数集合*/
#define TASK_DELETE_PARAMS(taskId, taskStatus, usrStack) taskId, taskStatus, usrStack/*这段代码是一个宏定义，用于定义任务删除所需的参数集合*/
#define TASK_SUSPEND_PARAMS(taskId, taskStatus, runTaskId) taskId, taskStatus, runTaskId/*这段代码是一个宏定义，用于定义任务挂起所需的参数集合*/
#define TASK_RESUME_PARAMS(taskId, taskStatus, prio) taskId, taskStatus, prio/*这段代码是一个宏定义，用于定义任务恢复所需的参数集合*/
#define TASK_SIGNAL_PARAMS(taskId, signal, schedFlag) // taskId, signal, schedFlag/*这段代码是一个宏定义，用于定义任务信号所需的参数集合
#define SWTMR_START_PARAMS(swtmrId, mode, overrun, interval, expiry) swtmrId, mode, overrun, interval, expiry/*这段代码是一个宏定义，用于定义软定时器启动所需的参数集合*/
#define SWTMR_DELETE_PARAMS(swtmrId) swtmrId/*这段代码是一个宏定义，用于定义软定时器删除所需的参数集合*/
#define SWTMR_EXPIRED_PARAMS(swtmrId) swtmrId/*这段代码是一个宏定义，用于定义软定时器到期所需的参数集合。*/
#define SWTMR_STOP_PARAMS(swtmrId) swtmrId/*这段代码是一个宏定义，用于定义软定时器停止所需的参数集合*/
#define SWTMR_CREATE_PARAMS(swtmrId) swtmrId
#define HWI_CREATE_PARAMS(hwiNum, hwiPrio, hwiMode, hwiHandler) hwiNum, hwiPrio, hwiMode, hwiHandler
#define HWI_CREATE_SHARE_PARAMS(hwiNum, pDevId, ret) hwiNum, pDevId, ret
#define HWI_DELETE_PARAMS(hwiNum) hwiNum
#define HWI_DELETE_SHARE_PARAMS(hwiNum, pDevId, ret) hwiNum, pDevId, ret
#define HWI_RESPONSE_IN_PARAMS(hwiNum) hwiNum
#define HWI_RESPONSE_OUT_PARAMS(hwiNum) hwiNum
#define HWI_ENABLE_PARAMS(hwiNum) hwiNum
#define HWI_DISABLE_PARAMS(hwiNum) hwiNum
#define HWI_TRIGGER_PARAMS(hwiNum) hwiNum
#define HWI_SETPRI_PARAMS(hwiNum, priority) hwiNum, priority
#define HWI_CLEAR_PARAMS(hwiNum) hwiNum
#define HWI_SETAFFINITY_PARAMS(hwiNum, cpuMask) hwiNum, cpuMask
#define HWI_SENDIPI_PARAMS(hwiNum, cpuMask) hwiNum, cpuMask
#define EVENT_CREATE_PARAMS(eventCB) eventCB
#define EVENT_DELETE_PARAMS(eventCB, delRetCode) eventCB, delRetCode
#define HWI_CREATE_PARAMS(hwiNum, hwiPrio, hwiMode, hwiHandler) hwiNum, hwiPrio, hwiMode, hwiHandler/*这段代码是一个宏定义，用于定义创建软定时器所需的参数集合*/
#define HWI_CREATE_SHARE_PARAMS(hwiNum, pDevId, ret) hwiNum, pDevId, ret/*这段代码是一个宏定义，用于定义创建硬件中断所需的参数集合*/
#define HWI_DELETE_PARAMS(hwiNum) hwiNum/*这段代码是一个宏定义，用于定义中断删除所需的参数集合*/
#define HWI_DELETE_SHARE_PARAMS(hwiNum, pDevId, ret) hwiNum, pDevId, ret/*这段代码是一个宏定义，用于定义共享中断删除所需的参数集合*/
#define HWI_RESPONSE_IN_PARAMS(hwiNum) hwiNum/*这段代码是一个宏定义，用于定义中断响应输入参数*/
#define HWI_RESPONSE_OUT_PARAMS(hwiNum) hwiNum/*这段代码是一个宏定义，用于定义中断响应输出参数*/
#define HWI_ENABLE_PARAMS(hwiNum) hwiNum/*这段代码是一个宏定义，用于定义中断使能所需的参数集合*/
#define HWI_DISABLE_PARAMS(hwiNum) hwiNum/*这段代码是一个宏定义，用于定义中断禁用所需的参数集合*/
#define HWI_TRIGGER_PARAMS(hwiNum) hwiNum/*这段代码是一个宏定义，用于定义触发中断所需的参数集合*/
#define HWI_SETPRI_PARAMS(hwiNum, priority) hwiNum, priority/*这段代码是一个宏定义，用于定义设置中断优先级所需的参数集合*/
#define HWI_CLEAR_PARAMS(hwiNum) hwiNum/*这段代码是一个宏定义，用于定义清除中断所需的参数集合*/
#define HWI_SETAFFINITY_PARAMS(hwiNum, cpuMask) hwiNum, cpuMask/*这段代码是一个宏定义，用于定义设置中断亲和性（affinity）所需的参数集合*/
#define HWI_SENDIPI_PARAMS(hwiNum, cpuMask) hwiNum, cpuMask/*这段代码是一个宏定义，用于定义发送中断处理器间中断（IPI）所需的参数集合*/
#define EVENT_CREATE_PARAMS(eventCB) eventCB/*这段代码是一个宏定义，用于定义创建事件（event）所需的参数集合*/
#define EVENT_DELETE_PARAMS(eventCB, delRetCode) eventCB, delRetCode/*这段代码是一个宏定义，用于定义删除事件（event）所需的参数集合*/
#define EVENT_READ_PARAMS(eventCB, eventId, mask, mode, timeout) \
eventCB, eventId, mask, mode, timeout
#define EVENT_WRITE_PARAMS(eventCB, eventId, events) eventCB, eventId, events
#define EVENT_CLEAR_PARAMS(eventCB, eventId, events) eventCB, eventId, events
#define EVENT_WRITE_PARAMS(eventCB, eventId, events) eventCB, eventId, events/*这段代码是一个宏定义，用于定义读取事件（event）所需的参数集合*/
#define EVENT_CLEAR_PARAMS(eventCB, eventId, events) eventCB, eventId, events/*这段代码是一个宏定义，用于定义清除事件（event）所需的参数集合*/
#define QUEUE_CREATE_PARAMS(queueId, queueSz, itemSz, queueAddr, memType) \
#define QUEUE_CREATE_PARAMS(queueId, queueSz, itemSz, queueAddr, memType) \/*这段代码是一个宏定义，用于定义创建队列（queue）所需的参数*/
queueId, queueSz, itemSz, queueAddr, memType
#define QUEUE_DELETE_PARAMS(queueId, state, readable) queueId, state, readable
#define QUEUE_RW_PARAMS(queueId, queueSize, bufSize, operateType, readable, writeable, timeout) \
#define QUEUE_DELETE_PARAMS(queueId, state, readable) queueId, state, readable/*这段代码是一个宏定义，用于定义删除队列（queue）所需的参数集合*/
#define QUEUE_RW_PARAMS(queueId, queueSize, bufSize, operateType, readable, writeable, timeout) \/*这段代码是一个宏定义，用于定义读写队列（queue）所需的参数集合*/
queueId, queueSize, bufSize, operateType, readable, writeable, timeout
#define SEM_CREATE_PARAMS(semId, type, count) semId, type, count
#define SEM_DELETE_PARAMS(semId, delRetCode) semId, delRetCode
#define SEM_PEND_PARAMS(semId, count, timeout) semId, count, timeout
#define SEM_POST_PARAMS(semId, type, count) semId, type, count
#define SEM_CREATE_PARAMS(semId, type, count) semId, type, count/*这段代码是一个宏定义，用于定义创建信号量（semaphore）所需的参数集合*/
#define SEM_DELETE_PARAMS(semId, delRetCode) semId, delRetCode/*这段代码是一个宏定义，用于定义删除信号量（semaphore）所需的参数集合*/
#define SEM_PEND_PARAMS(semId, count, timeout) semId, count, timeout/*这段代码是一个宏定义，用于定义等待信号量（semaphore）所需的参数集合*/
#define SEM_POST_PARAMS(semId, type, count) semId, type, count/*这段代码是一个宏定义，用于定义发送信号量（semaphore）所需的参数集合*/
#define MUX_CREATE_PARAMS(muxId) muxId
#define MUX_DELETE_PARAMS(muxId, state, count, owner) muxId, state, count, owner
#define MUX_PEND_PARAMS(muxId, count, owner, timeout) muxId, count, owner, timeout
#define MUX_POST_PARAMS(muxId, count, owner) muxId, count, owner
#define MUX_CREATE_PARAMS(muxId) muxId/*这段代码是一个宏定义，用于定义创建互斥量（mutex）所需的参数*/
#define MUX_DELETE_PARAMS(muxId, state, count, owner) muxId, state, count, owner/*这段代码是一个宏定义，用于定义删除互斥量（mutex）所需的参数集合*/
#define MUX_PEND_PARAMS(muxId, count, owner, timeout) muxId, count, owner, timeout/*这段代码是一个宏定义，用于定义等待互斥量（mutex）所需的参数集合*/
#define MUX_POST_PARAMS(muxId, count, owner) muxId, count, owner/*这段代码是一个宏定义，用于定义发送互斥量（mutex）所需的参数集合*/
#define MEM_ALLOC_PARAMS(pool, ptr, size) pool, ptr, size
#define MEM_ALLOC_ALIGN_PARAMS(pool, ptr, size, boundary) pool, ptr, size, boundary
#define MEM_REALLOC_PARAMS(pool, ptr, size) pool, ptr, size
#define MEM_FREE_PARAMS(pool, ptr) pool, ptr
#define MEM_INFO_REQ_PARAMS(pool) pool
#define MEM_INFO_PARAMS(pool, usedSize, freeSize) pool, usedSize, freeSize
#define MEM_ALLOC_PARAMS(pool, ptr, size) pool, ptr, size/*这段代码是一个宏定义，用于定义内存分配（memory allocation）所需的参数集合*/
#define MEM_ALLOC_ALIGN_PARAMS(pool, ptr, size, boundary) pool, ptr, size, boundary/*这段代码是一个宏定义，用于定义内存分配对齐（alignment）所需的参数集合*/
#define MEM_REALLOC_PARAMS(pool, ptr, size) pool, ptr, size/*这段代码是一个宏定义，用于定义重新分配内存（memory reallocation）所需的参数集合*/
#define MEM_FREE_PARAMS(pool, ptr) pool, ptr/*这段代码是一个宏定义，用于定义内存释放（memory deallocation）所需的参数集合*/
#define MEM_INFO_REQ_PARAMS(pool) pool/*这段代码是一个宏定义，用于定义获取内存信息请求（memory information request）所需的参数集合*/
#define MEM_INFO_PARAMS(pool, usedSize, freeSize) pool, usedSize, freeSize/*这段代码是一个宏定义，用于定义内存信息（memory information）所需的参数集合*/
#define SYS_ERROR_PARAMS(errno) errno
@ -405,7 +427,15 @@ extern TRACE_EVENT_HOOK g_traceEventHook;
#else
#define LOS_TRACE(TYPE, ...) LOS_PERF(TYPE)
#endif
/*这段代码是一个宏定义，用于在源代码中插入跟踪代码存根，以追踪事件
宏定义内部的实现逻辑如下：
首先调用LOS_PERF宏，执行与性能相关的操作。
创建一个名为_inner的数组，将事件类型和参数存储其中。数组的第一个元素为0，表示未知。
获取_inner数组的长度，并判断是否大于1，并且全局变量g_traceEventHook不为空。
如果满足条件，则调用g_traceEventHook函数，将事件类型、第二个元素以及后续元素传递给该函数。
宏定义结束。*/
#ifdef LOSCFG_KERNEL_TRACE
/**
@ -437,7 +467,13 @@ extern TRACE_EVENT_HOOK g_traceEventHook;
#else
#define LOS_TRACE_EASY(...)
#endif
/*这段代码是一个宏定义，用于在源代码中插入用户自定义的跟踪代码存根，以简单地追踪事件
宏定义内部的实现逻辑如下：
创建一个名为_inner的数组，将参数存储其中。数组的第一个元素为0，表示未知。
获取_inner数组的长度，并判断是否大于1，并且全局变量g_traceEventHook不为空。
如果满足条件，则调用g_traceEventHook函数，将标志为TRACE_USER_DEFAULT_FLAG | TYPE的事件类型、身份标识、第二个元素以及后续元素传递给该函数。
宏定义结束*/
/**
* @ingroup los_trace
* @brief Intialize the trace when the system startup.
@ -465,7 +501,19 @@ extern TRACE_EVENT_HOOK g_traceEventHook;
* @since Huawei LiteOS V200R005C00
*/
extern UINT32 LOS_TraceInit(VOID *buf, UINT32 size);
/*这段代码定义了一个名为LOS_TraceInit的函数，用于初始化系统级别的跟踪功能
函数实现逻辑如下：
首先判断跟踪状态是否为TRACE_UNINIT，如果不是则返回错误码LOS_ERRNO_TRACE_ERROR_STATUS。
然后检查是否有足够的内存来初始化跟踪，如果没有则返回LOS_ERRNO_TRACE_NO_MEMORY。
检查跟踪缓冲区的大小是否足够，如果不够则返回LOS_ERRNO_TRACE_BUF_TOO_SMALL。
调用LOS_MpCreate接口创建跟踪任务的同步资源，如果失败则返回错误码LOS_ERRNO_TSK_MP_SYNC_RESOURCE。
创建跟踪任务的控制块，如果失败则返回错误码LOS_ERRNO_TSK_TCB_UNAVAILABLE。
初始化跟踪任务的消息队列。
完成跟踪缓冲区的初始化。
初始化其他跟踪相关参数。
设置跟踪状态为TRACE_IDLE。
完成初始化。*/
/**
* @ingroup los_trace
* @brief Start trace.
@ -487,7 +535,7 @@ extern UINT32 LOS_TraceInit(VOID *buf, UINT32 size);
* @since Huawei LiteOS V200R005C00
*/
extern UINT32 LOS_TraceStart(VOID);
/*这段代码定义了一个名为LOS_TraceStart的函数，用于启动跟踪功能*/
/**
* @ingroup los_trace
* @brief Stop trace sample.
@ -508,7 +556,7 @@ extern UINT32 LOS_TraceStart(VOID);
* @since Huawei LiteOS V200R005C00
*/
extern VOID LOS_TraceStop(VOID);
/*这段代码定义了一个名为LOS_TraceStop的函数，用于停止跟踪采样*/
/**
* @ingroup los_trace
* @brief Clear the trace buf.
@ -529,7 +577,7 @@ extern VOID LOS_TraceStop(VOID);
* @since Huawei LiteOS V200R005C00
*/
extern VOID LOS_TraceReset(VOID);
/*这段代码定义了一个名为LOS_TraceReset的函数，用于清空跟踪缓冲区中的事件帧，仅在离线模式下有效*/
/**
* @ingroup los_trace
* @brief Set trace event mask.
@ -553,7 +601,7 @@ extern VOID LOS_TraceReset(VOID);
* @since Huawei LiteOS V200R005C00
*/
extern VOID LOS_TraceEventMaskSet(UINT32 mask);
/*这段代码定义了一个名为LOS_TraceEventMaskSet的函数，用于设置跟踪事件的掩码*/
/**
* @ingroup los_trace
* @brief Offline trace buffer display.
@ -576,7 +624,7 @@ extern VOID LOS_TraceEventMaskSet(UINT32 mask);
* @since Huawei LiteOS V200R005C00
*/
extern VOID LOS_TraceRecordDump(BOOL toClient);
/*这段代码定义了一个名为LOS_TraceRecordDump的函数，用于在离线模式下显示跟踪缓冲区数据*/
/**
* @ingroup los_trace
* @brief Offline trace buffer export.
@ -599,7 +647,7 @@ extern VOID LOS_TraceRecordDump(BOOL toClient);
* @since Huawei LiteOS V200R005C00
*/
extern OfflineHead *LOS_TraceRecordGet(VOID);
/*这段代码定义了一个名为LOS_TraceRecordGet的函数，用于在离线模式下导出跟踪缓冲区数据*/
/**
* @ingroup los_trace
* @brief Hwi num fliter hook.
@ -620,6 +668,7 @@ extern OfflineHead *LOS_TraceRecordGet(VOID);
* @since Huawei LiteOS V200R005C00
*/
extern VOID LOS_TraceHwiFilterHookReg(TRACE_HWI_FILTER_HOOK hook);
/*这段代码定义了一个名为LOS_TraceHwiFilterHookReg的函数，用于注册硬件中断（Hwi）号码过滤钩子函数*/
#ifdef __cplusplus
#if __cplusplus
}

13
src/kernel/include/virtual_serial.h
Unescape View File

@ -25,7 +25,8 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */
/*代码是一个虚拟串口头文件，用于定义虚拟串口的初始化、反初始化和获取串口类型等函数。在这个头文件中，还定义了一个名为LOS_VIRSERIAL_CB的结构体，
用于表示虚拟串口的控制、配置或状态管理。此外，代码中还包含了一些条件编译的指令，用于根据配置情况包含相应的头文件或功能实现*/
#ifndef _VIRTUAL_SERIAL_H
#define _VIRTUAL_SERIAL_H
@ -51,16 +52,20 @@ extern "C" {
#define SERIAL_TYPE_UART_DEV 1
#define SERIAL_TYPE_USBTTY_DEV 2
extern INT32 virtual_serial_init(const CHAR *deviceName);
extern INT32 virtual_serial_deinit(VOID);
extern INT32 virtual_serial_init(const CHAR *deviceName);/*这段代码声明了一个函数原型 virtual_serial_init，用于初始化虚拟串口设备*/
extern INT32 virtual_serial_deinit(VOID);/*这段代码声明了一个函数原型 virtual_serial_deinit，用于反初始化虚拟串口设备*/
extern UINT32 SerialTypeGet(VOID);
extern UINT32 SerialTypeGet(VOID);/*这段代码声明了一个函数原型 SerialTypeGet，用于获取串口类型的函数*/
typedef struct {
struct file *filep;
UINT32 mask;
} LOS_VIRSERIAL_CB;
/*这段代码定义了一个结构体 LOS_VIRSERIAL_CB，包含两个成员变量：
filep：指向 struct file 类型的指针，表示一个文件指针。
mask：无符号整数类型 UINT32，用于表示掩码。
这个结构体的作用可能是用于虚拟串口的控制、配置或状态管理。其中的 filep 可能用于表示虚拟串口对应的文件，而 mask 则可能用于存储一些状态或掩码信息。*/
#endif
#ifdef __cplusplus

Write Preview
Loading…
Cancel
Save