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

Compare commits

base: p2gpamesw:master
Branches Tags
p2gpamesw:master
p2gpamesw:wenhao_branch
p2gpamesw:cailun_branch
p2gpamesw:wangweilun_branch
p2gpamesw:zhangxinyuan_branch
p2gpamesw:oujiashu_branch
p2gpamesw:hejiacong_branch
p2gpamesw:fuaojia_branch
p2gpamesw:develop
..
compare: p2gpamesw:hejiacong_branch
Branches Tags
p2gpamesw:master
p2gpamesw:wenhao_branch
p2gpamesw:cailun_branch
p2gpamesw:wangweilun_branch
p2gpamesw:zhangxinyuan_branch
p2gpamesw:oujiashu_branch
p2gpamesw:hejiacong_branch
p2gpamesw:fuaojia_branch
p2gpamesw:develop

No commits in common. 'master' and 'hejiacong_branch' have entirely different histories.
master ... hejiacong_

110 changed files with 1111 additions and 3461 deletions
Show Stats

BIN
doc/LiteOS泛读报告.docx
View File

Binary file not shown.

BIN
doc/何佳聪 泛读报告.docx
View File

Binary file not shown.

31
src/kernel/base/debug/los_mux_deadlock.c
Unescape View File

@ -38,17 +38,16 @@
#if __cplusplus #if __cplusplus
extern "C" { extern "C" {
#endif #endif
#endif /* __cplusplus */nbb #endif /* __cplusplus */
typedef struct { typedef struct {
LOS_DL_LIST muxListHead; /* Task-held mutexs list */ //用于管理任务持有的互斥锁列表// LOS_DL_LIST muxListHead; /* Task-held mutexs list */
UINT64 lastAccessTime; /* The last operation time */ //记录最后一次操作的时间// UINT64 lastAccessTime; /* The last operation time */
} MuxDLinkCB; } MuxDLinkCB;
/*管理任务持有的互斥锁列表和跟踪死锁情况*/
typedef struct { typedef struct {
LOS_DL_LIST muxList; /* Insert mutex into the owner task CB */ //用于将互斥锁插入到所属任务的控制块中// LOS_DL_LIST muxList; /* Insert mutex into the owner task CB */
VOID *muxCB; /* The Mutex CB pointer */ //指向互斥锁控制块的指针// VOID *muxCB; /* The Mutex CB pointer */
} MuxDLinkNode; } MuxDLinkNode;
STATIC MuxDLinkCB *g_muxDeadlockCBArray = NULL; STATIC MuxDLinkCB *g_muxDeadlockCBArray = NULL;
@ -58,9 +57,9 @@ STATIC MuxDLinkCB *g_muxDeadlockCBArray = NULL;
* that has not been scheduled within this time. * that has not been scheduled within this time.
* The unit is tick. * The unit is tick.
*/ */
#define OS_MUX_DEADLOCK_CHECK_THRESHOLD 60000 //定义两次检查互斥锁死锁之间的最小时间间隔，单位为毫秒// #define OS_MUX_DEADLOCK_CHECK_THRESHOLD 60000
UINT32 OsMuxDlockCheckInit(VOID) //用于分配内存并初始化互斥锁控制块列表// UINT32 OsMuxDlockCheckInit(VOID)
{ {
UINT32 index; UINT32 index;
UINT32 size = (LOSCFG_BASE_CORE_TSK_LIMIT + 1) * sizeof(MuxDLinkCB); UINT32 size = (LOSCFG_BASE_CORE_TSK_LIMIT + 1) * sizeof(MuxDLinkCB);
@ -79,7 +78,7 @@ UINT32 OsMuxDlockCheckInit(VOID) //
return LOS_OK; return LOS_OK;
} }
VOID OsMuxDlockNodeInsert(UINT32 taskId, VOID *muxCB) //用于向指定任务的互斥锁链表中插入一个互斥锁节点// VOID OsMuxDlockNodeInsert(UINT32 taskId, VOID *muxCB)
{ {
MuxDLinkNode *muxDLNode = NULL; MuxDLinkNode *muxDLNode = NULL;
@ -97,7 +96,7 @@ VOID OsMuxDlockNodeInsert(UINT32 taskId, VOID *muxCB) //
LOS_ListTailInsert(&g_muxDeadlockCBArray[taskId].muxListHead, &muxDLNode->muxList); LOS_ListTailInsert(&g_muxDeadlockCBArray[taskId].muxListHead, &muxDLNode->muxList);
} }
VOID OsMuxDlockNodeDelete(UINT32 taskId, const VOID *muxCB) //用于从指定任务的互斥锁链表中删除指定的互斥锁节点// VOID OsMuxDlockNodeDelete(UINT32 taskId, const VOID *muxCB)
{ {
MuxDLinkCB *muxDLCB = NULL; MuxDLinkCB *muxDLCB = NULL;
LOS_DL_LIST *list = NULL; LOS_DL_LIST *list = NULL;
@ -118,7 +117,7 @@ VOID OsMuxDlockNodeDelete(UINT32 taskId, const VOID *muxCB) //
} }
} }
VOID OsTaskTimeUpdate(UINT32 taskId, UINT64 tickCount) //用于更新任务的最后访问时间// VOID OsTaskTimeUpdate(UINT32 taskId, UINT64 tickCount)
{ {
if (taskId > LOSCFG_BASE_CORE_TSK_LIMIT) { if (taskId > LOSCFG_BASE_CORE_TSK_LIMIT) {
return; return;
@ -127,7 +126,7 @@ VOID OsTaskTimeUpdate(UINT32 taskId, UINT64 tickCount) //
g_muxDeadlockCBArray[taskId].lastAccessTime = tickCount; g_muxDeadlockCBArray[taskId].lastAccessTime = tickCount;
} }
STATIC VOID OsDeadlockBackTrace(const LosTaskCB *taskCB) //用于打印任务的函数调用栈信息// STATIC VOID OsDeadlockBackTrace(const LosTaskCB *taskCB)
{ {
TaskContext *context = NULL; TaskContext *context = NULL;
@ -138,7 +137,7 @@ STATIC VOID OsDeadlockBackTrace(const LosTaskCB *taskCB) //
return; return;
} }
STATIC VOID OsMutexPendTaskList(LOS_DL_LIST *list) //用于打印互斥锁等待任务的列表信息// STATIC VOID OsMutexPendTaskList(LOS_DL_LIST *list)
{ {
LOS_DL_LIST *listTmp = NULL; LOS_DL_LIST *listTmp = NULL;
LosTaskCB *pendedTask = NULL; LosTaskCB *pendedTask = NULL;
@ -169,7 +168,7 @@ STATIC VOID OsMutexPendTaskList(LOS_DL_LIST *list) //
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
} }
STATIC VOID OsTaskHoldMutexList(MuxDLinkCB *muxDLCB) //用于打印任务持有的互斥锁的信息// STATIC VOID OsTaskHoldMutexList(MuxDLinkCB *muxDLCB)
{ {
UINT32 index = 0; UINT32 index = 0;
MuxDLinkNode *muxDLNode = NULL; MuxDLinkNode *muxDLNode = NULL;
@ -205,7 +204,7 @@ STATIC VOID OsTaskHoldMutexList(MuxDLinkCB *muxDLCB) //
} }
} }
VOID OsMutexDlockCheck(VOID) //用于检测互斥锁死锁情况并输出相关信息// VOID OsMutexDlockCheck(VOID)
{ {
UINT32 loop, intSave; UINT32 loop, intSave;
UINT32 taskId; UINT32 taskId;
@ -235,7 +234,7 @@ VOID OsMutexDlockCheck(VOID) //
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
} }
#ifdef LOSCFG_SHELL //用于在命令行中执行互斥锁死锁检查并输出相关信息// #ifdef LOSCFG_SHELL
UINT32 OsShellCmdMuxDeadlockCheck(UINT32 argc, const CHAR **argv) UINT32 OsShellCmdMuxDeadlockCheck(UINT32 argc, const CHAR **argv)
{ {
if (argc > 0) { if (argc > 0) {

13
src/kernel/base/debug/los_mux_debug.c
Unescape View File

@ -41,21 +41,20 @@ extern "C" {
#endif #endif
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_DEBUG_MUTEX //用于表示互斥锁的调试信息// #ifdef LOSCFG_DEBUG_MUTEX
typedef struct { typedef struct {
TSK_ENTRY_FUNC creator; /* The task entry who created this mutex */ TSK_ENTRY_FUNC creator; /* The task entry who created this mutex */
UINT64 lastAccessTime; /* The last access time */ UINT64 lastAccessTime; /* The last access time */
} MuxDebugCB; } MuxDebugCB;
STATIC MuxDebugCB *g_muxDebugArray = NULL; STATIC MuxDebugCB *g_muxDebugArray = NULL;
//用于比较两个互斥锁调试信息的最后访问时间//
STATIC BOOL MuxCompareValue(const SortParam *sortParam, UINT32 left, UINT32 right) STATIC BOOL MuxCompareValue(const SortParam *sortParam, UINT32 left, UINT32 right)
{ {
return (*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, left)) > return (*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, left)) >
*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, right))); *((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, right)));
} }
UINT32 OsMuxDbgInit(VOID) //用于初始化互斥锁调试信息数组// UINT32 OsMuxDbgInit(VOID)
{ {
UINT32 size = LOSCFG_BASE_IPC_MUX_LIMIT * sizeof(MuxDebugCB); UINT32 size = LOSCFG_BASE_IPC_MUX_LIMIT * sizeof(MuxDebugCB);
/* system resident memory, don't free */ /* system resident memory, don't free */
@ -68,20 +67,19 @@ UINT32 OsMuxDbgInit(VOID) //
return LOS_OK; return LOS_OK;
} }
VOID OsMuxDbgTimeUpdate(UINT32 muxId) //用于更新指定互斥锁的最后访问时间// VOID OsMuxDbgTimeUpdate(UINT32 muxId)
{ {
MuxDebugCB *muxDebug = &g_muxDebugArray[GET_MUX_INDEX(muxId)]; MuxDebugCB *muxDebug = &g_muxDebugArray[GET_MUX_INDEX(muxId)];
muxDebug->lastAccessTime = LOS_TickCountGet(); muxDebug->lastAccessTime = LOS_TickCountGet();
} }
VOID OsMuxDbgUpdate(UINT32 muxId, TSK_ENTRY_FUNC creator) //用于更新指定互斥锁的创建者和最后访问时间// VOID OsMuxDbgUpdate(UINT32 muxId, TSK_ENTRY_FUNC creator)
{ {
MuxDebugCB *muxDebug = &g_muxDebugArray[GET_MUX_INDEX(muxId)]; MuxDebugCB *muxDebug = &g_muxDebugArray[GET_MUX_INDEX(muxId)];
muxDebug->creator = creator; muxDebug->creator = creator;
muxDebug->lastAccessTime = LOS_TickCountGet(); muxDebug->lastAccessTime = LOS_TickCountGet();
} }
//用于对互斥锁索引数组进行排序，并检查可能存在的互斥锁泄漏//
STATIC VOID SortMuxIndexArray(UINT32 *indexArray, UINT32 count) STATIC VOID SortMuxIndexArray(UINT32 *indexArray, UINT32 count)
{ {
LosMuxCB muxNode = {{0, 0}, 0, 0, 0, 0}; LosMuxCB muxNode = {{0, 0}, 0, 0, 0, 0};
@ -121,7 +119,7 @@ STATIC VOID SortMuxIndexArray(UINT32 *indexArray, UINT32 count)
(VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, indexArray); (VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, indexArray);
} }
VOID OsMutexCheck(VOID) //用于检查互斥锁的状态并对可能存在的互斥锁泄漏进行处理// VOID OsMutexCheck(VOID)
{ {
LosMuxCB muxNode = {{0, 0}, 0, 0, 0, 0}; LosMuxCB muxNode = {{0, 0}, 0, 0, 0, 0};
MuxDebugCB muxDebugNode = {0}; MuxDebugCB muxDebugNode = {0};
@ -167,7 +165,6 @@ VOID OsMutexCheck(VOID) //
} }
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
//用于获取互斥锁信息//
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMuxInfoGet(UINT32 argc, const CHAR **argv) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMuxInfoGet(UINT32 argc, const CHAR **argv)
{ {
if (argc > 0) { if (argc > 0) {

18
src/kernel/base/debug/los_queue_debug.c
Unescape View File

@ -38,21 +38,20 @@ extern "C" {
#endif #endif
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_DEBUG_QUEUE //用于保存队列的调试信息// #ifdef LOSCFG_DEBUG_QUEUE
typedef struct { typedef struct {
TSK_ENTRY_FUNC creator; /* The task entry who created this queue */ TSK_ENTRY_FUNC creator; /* The task entry who created this queue */
UINT64 lastAccessTime; /* The last access time */ UINT64 lastAccessTime; /* The last access time */
} QueueDebugCB; } QueueDebugCB;
STATIC QueueDebugCB *g_queueDebugArray = NULL; STATIC QueueDebugCB *g_queueDebugArray = NULL;
//用于比较队列中的元素值//
STATIC BOOL QueueCompareValue(const SortParam *sortParam, UINT32 left, UINT32 right) STATIC BOOL QueueCompareValue(const SortParam *sortParam, UINT32 left, UINT32 right)
{ {
return (*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, left)) > return (*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, left)) >
*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, right))); *((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, right)));
} }
UINT32 OsQueueDbgInit(VOID) //用于初始化队列的调试信息// UINT32 OsQueueDbgInit(VOID)
{ {
UINT32 size = LOSCFG_BASE_IPC_QUEUE_LIMIT * sizeof(QueueDebugCB); UINT32 size = LOSCFG_BASE_IPC_QUEUE_LIMIT * sizeof(QueueDebugCB);
@ -66,14 +65,14 @@ UINT32 OsQueueDbgInit(VOID) //
return LOS_OK; return LOS_OK;
} }
VOID OsQueueDbgTimeUpdate(UINT32 queueId) //用于更新队列的最后访问时间// VOID OsQueueDbgTimeUpdate(UINT32 queueId)
{ {
QueueDebugCB *queueDebug = &g_queueDebugArray[GET_QUEUE_INDEX(queueId)]; QueueDebugCB *queueDebug = &g_queueDebugArray[GET_QUEUE_INDEX(queueId)];
queueDebug->lastAccessTime = LOS_TickCountGet(); queueDebug->lastAccessTime = LOS_TickCountGet();
return; return;
} }
VOID OsQueueDbgUpdate(UINT32 queueId, TSK_ENTRY_FUNC entry) //用于更新队列的调试信息// VOID OsQueueDbgUpdate(UINT32 queueId, TSK_ENTRY_FUNC entry)
{ {
QueueDebugCB *queueDebug = &g_queueDebugArray[GET_QUEUE_INDEX(queueId)]; QueueDebugCB *queueDebug = &g_queueDebugArray[GET_QUEUE_INDEX(queueId)];
queueDebug->creator = entry; queueDebug->creator = entry;
@ -81,7 +80,7 @@ VOID OsQueueDbgUpdate(UINT32 queueId, TSK_ENTRY_FUNC entry) //
return; return;
} }
STATIC INLINE VOID OsQueueInfoOutPut(const LosQueueCB *node) //用于输出队列的信息// STATIC INLINE VOID OsQueueInfoOutPut(const LosQueueCB *node)
{ {
PRINTK("Queue ID <0x%x> may leak, queue len is 0x%x, " PRINTK("Queue ID <0x%x> may leak, queue len is 0x%x, "
"readable cnt:0x%x, writeable cnt:0x%x, ", "readable cnt:0x%x, writeable cnt:0x%x, ",
@ -91,13 +90,13 @@ STATIC INLINE VOID OsQueueInfoOutPut(const LosQueueCB *node) //
node->readWriteableCnt[OS_QUEUE_WRITE]); node->readWriteableCnt[OS_QUEUE_WRITE]);
} }
STATIC INLINE VOID OsQueueOpsOutput(const QueueDebugCB *node) //用于输出队列操作的信息// STATIC INLINE VOID OsQueueOpsOutput(const QueueDebugCB *node)
{ {
PRINTK("TaskEntry of creator:0x%p, Latest operation time: 0x%llx\n", PRINTK("TaskEntry of creator:0x%p, Latest operation time: 0x%llx\n",
node->creator, node->lastAccessTime); node->creator, node->lastAccessTime);
} }
STATIC VOID SortQueueIndexArray(UINT32 *indexArray, UINT32 count) //用于对队列索引数组进行排序并输出相应的队列信息// STATIC VOID SortQueueIndexArray(UINT32 *indexArray, UINT32 count)
{ {
LosQueueCB queueNode = {0}; LosQueueCB queueNode = {0};
QueueDebugCB queueDebugNode = {0}; QueueDebugCB queueDebugNode = {0};
@ -129,7 +128,7 @@ STATIC VOID SortQueueIndexArray(UINT32 *indexArray, UINT32 count) //
(VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, indexArray); (VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, indexArray);
} }
VOID OsQueueCheck(VOID) //用于检查队列的状态并输出相应信息// VOID OsQueueCheck(VOID)
{ {
LosQueueCB queueNode = {0}; LosQueueCB queueNode = {0};
QueueDebugCB queueDebugNode = {0}; QueueDebugCB queueDebugNode = {0};
@ -183,7 +182,6 @@ VOID OsQueueCheck(VOID) //
} }
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
//当用户输入 "queue" 命令时，会输出已使用队列的信息//
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdQueueInfoGet(UINT32 argc, const CHAR **argv) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdQueueInfoGet(UINT32 argc, const CHAR **argv)
{ {
if (argc > 0) { if (argc > 0) {

31
src/kernel/base/debug/los_sched_debug.c
Unescape View File

@ -40,17 +40,17 @@ extern "C" {
#define DECIMAL_TO_PERCENTAGE 100 #define DECIMAL_TO_PERCENTAGE 100
typedef struct { typedef struct {
UINT64 idleRuntime; //空闲任务的运行时间// UINT64 idleRuntime;
UINT64 idleStarttime; //空闲任务的启动时间// UINT64 idleStarttime;
UINT64 highTaskRuntime; //高优先级任务的运行时间// UINT64 highTaskRuntime;
UINT64 highTaskStarttime; //高优先级任务的启动时间// UINT64 highTaskStarttime;
UINT64 sumPriority; //任务优先级之和// UINT64 sumPriority;
UINT32 prioritySwitch; //任务切换次数// UINT32 prioritySwitch;
UINT32 highTaskSwitch; //高优先级任务切换次数// UINT32 highTaskSwitch;
UINT32 contexSwitch; //上下文切换次数// UINT32 contexSwitch;
UINT32 hwiNum; //硬件中断次数// UINT32 hwiNum;
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
UINT32 ipiIrqNum; //中断次数（仅在多核配置下定义）// UINT32 ipiIrqNum;
#endif #endif
} StatPercpu; } StatPercpu;
@ -58,7 +58,6 @@ STATIC BOOL g_statisticsStartFlag = FALSE;
STATIC UINT64 g_statisticsStartTime; STATIC UINT64 g_statisticsStartTime;
STATIC StatPercpu g_statPercpu[LOSCFG_KERNEL_CORE_NUM]; STATIC StatPercpu g_statPercpu[LOSCFG_KERNEL_CORE_NUM];
//用于在每个 CPU 核心上进行调度统计//
STATIC VOID OsSchedStatisticsPerCpu(const LosTaskCB *runTask, const LosTaskCB *newTask) STATIC VOID OsSchedStatisticsPerCpu(const LosTaskCB *runTask, const LosTaskCB *newTask)
{ {
UINT32 cpuId; UINT32 cpuId;
@ -107,7 +106,6 @@ STATIC VOID OsSchedStatisticsPerCpu(const LosTaskCB *runTask, const LosTaskCB *n
return; return;
} }
//用于更新调度统计信息//
LITE_OS_SEC_TEXT_MINOR VOID OsSchedStatistics(LosTaskCB *runTask, LosTaskCB *newTask) LITE_OS_SEC_TEXT_MINOR VOID OsSchedStatistics(LosTaskCB *runTask, LosTaskCB *newTask)
{ {
UINT64 runtime; UINT64 runtime;
@ -133,7 +131,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSchedStatistics(LosTaskCB *runTask, LosTaskCB *new
OsSchedStatisticsPerCpu(runTask, newTask); OsSchedStatisticsPerCpu(runTask, newTask);
} }
LITE_OS_SEC_TEXT_MINOR VOID OsHwiStatistics(size_t intNum) //用于更新硬中断的统计信息// LITE_OS_SEC_TEXT_MINOR VOID OsHwiStatistics(size_t intNum)
{ {
UINT32 cpuId = ArchCurrCpuid(); UINT32 cpuId = ArchCurrCpuid();
@ -151,7 +149,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsHwiStatistics(size_t intNum) //
return; return;
} }
LITE_OS_SEC_TEXT_MINOR VOID OsShellCmdDumpSched(VOID) //用于打印任务的调度统计信息// LITE_OS_SEC_TEXT_MINOR VOID OsShellCmdDumpSched(VOID)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
UINT32 loop; UINT32 loop;
@ -194,7 +192,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsShellCmdDumpSched(VOID) //
PRINTK("\n"); PRINTK("\n");
} }
LITE_OS_SEC_TEXT_MINOR VOID OsStatisticsShow(UINT64 statisticsPastTime) //用于显示系统的统计信息// LITE_OS_SEC_TEXT_MINOR VOID OsStatisticsShow(UINT64 statisticsPastTime)
{ {
UINT32 cpuId; UINT32 cpuId;
PRINTK("\n"); PRINTK("\n");
@ -240,7 +238,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsStatisticsShow(UINT64 statisticsPastTime) //
PRINTK("\n"); PRINTK("\n");
} }
LITE_OS_SEC_TEXT_MINOR VOID OsShellStatisticsStart(VOID) //用于在多核系统中启动统计功能// LITE_OS_SEC_TEXT_MINOR VOID OsShellStatisticsStart(VOID)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
UINT32 loop; UINT32 loop;
@ -287,7 +285,6 @@ LITE_OS_SEC_TEXT_MINOR VOID OsShellStatisticsStart(VOID) //
return; return;
} }
//用于在多核系统中停止统计功能，并进行统计数据的处理和展示//
LITE_OS_SEC_TEXT_MINOR VOID OsShellStatisticsStop(VOID) LITE_OS_SEC_TEXT_MINOR VOID OsShellStatisticsStop(VOID)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;

22
src/kernel/base/debug/los_sem_debug.c
Unescape View File

@ -44,7 +44,7 @@ extern "C" {
#ifdef LOSCFG_DEBUG_SEMAPHORE #ifdef LOSCFG_DEBUG_SEMAPHORE
#define OS_ALL_SEM_MASK 0xffffffff #define OS_ALL_SEM_MASK 0xffffffff
STATIC VOID OsSemPendedTaskNamePrint(LosSemCB *semNode) //用于打印等待某个信号量的任务列表// STATIC VOID OsSemPendedTaskNamePrint(LosSemCB *semNode)
{ {
LosTaskCB *tskCB = NULL; LosTaskCB *tskCB = NULL;
CHAR *nameArr[LOSCFG_BASE_CORE_TSK_LIMIT] = {0}; CHAR *nameArr[LOSCFG_BASE_CORE_TSK_LIMIT] = {0};
@ -76,21 +76,20 @@ STATIC VOID OsSemPendedTaskNamePrint(LosSemCB *semNode) //
PRINTK("\n"); PRINTK("\n");
} }
typedef struct { //用于记录信号量的调试信息// typedef struct {
UINT16 origSemCount; /* Number of original available semaphores */ UINT16 origSemCount; /* Number of original available semaphores */
UINT64 lastAccessTime; /* The last operation time */ UINT64 lastAccessTime; /* The last operation time */
TSK_ENTRY_FUNC creator; /* The task entry who created this sem */ TSK_ENTRY_FUNC creator; /* The task entry who created this sem */
} SemDebugCB; } SemDebugCB;
STATIC SemDebugCB *g_semDebugArray = NULL; //用于存储所有信号量的调试信息// STATIC SemDebugCB *g_semDebugArray = NULL;
//用于比较两个排序元素的值//
STATIC BOOL SemCompareValue(const SortParam *sortParam, UINT32 left, UINT32 right) STATIC BOOL SemCompareValue(const SortParam *sortParam, UINT32 left, UINT32 right)
{ {
return (*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, left)) > return (*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, left)) >
*((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, right))); *((UINT64 *)(VOID *)SORT_ELEM_ADDR(sortParam, right)));
} }
UINT32 OsSemDbgInit(VOID) //用于初始化信号量的调试信息数组// UINT32 OsSemDbgInit(VOID)
{ {
UINT32 size = LOSCFG_BASE_IPC_SEM_LIMIT * sizeof(SemDebugCB); UINT32 size = LOSCFG_BASE_IPC_SEM_LIMIT * sizeof(SemDebugCB);
/* system resident memory, don't free */ /* system resident memory, don't free */
@ -103,14 +102,14 @@ UINT32 OsSemDbgInit(VOID) //
return LOS_OK; return LOS_OK;
} }
VOID OsSemDbgTimeUpdate(UINT32 semId) //用于更新指定信号量的最后一次访问时间// VOID OsSemDbgTimeUpdate(UINT32 semId)
{ {
SemDebugCB *semDebug = &g_semDebugArray[GET_SEM_INDEX(semId)]; SemDebugCB *semDebug = &g_semDebugArray[GET_SEM_INDEX(semId)];
semDebug->lastAccessTime = LOS_TickCountGet(); semDebug->lastAccessTime = LOS_TickCountGet();
return; return;
} }
VOID OsSemDbgUpdate(UINT32 semId, TSK_ENTRY_FUNC creator, UINT16 count) //用于更新指定信号量的调试信息// VOID OsSemDbgUpdate(UINT32 semId, TSK_ENTRY_FUNC creator, UINT16 count)
{ {
SemDebugCB *semDebug = &g_semDebugArray[GET_SEM_INDEX(semId)]; SemDebugCB *semDebug = &g_semDebugArray[GET_SEM_INDEX(semId)];
semDebug->creator = creator; semDebug->creator = creator;
@ -119,9 +118,7 @@ VOID OsSemDbgUpdate(UINT32 semId, TSK_ENTRY_FUNC creator, UINT16 count) //
return; return;
} }
/*用于按照信号量的最后访问时间对当前正在使用的信号量进行排序，*/ STATIC VOID OsSemSort(UINT32 *semIndexArray, UINT32 usedCount)
/*并打印每个信号量的调试信息和等待该信号量的任务名*/
STATIC VOID OsSemSort(UINT32 *semIndexArray, UINT32 usedCount)
{ {
UINT32 i, intSave; UINT32 i, intSave;
LosSemCB *semCB = NULL; LosSemCB *semCB = NULL;
@ -157,7 +154,7 @@ STATIC VOID OsSemSort(UINT32 *semIndexArray, UINT32 usedCount)
} }
} }
} }
/*用于获取当前正在使用的信号量信息，并按照信号量的最后访问时间对信号量进行排序*/
UINT32 OsSemInfoGetFullData(VOID) UINT32 OsSemInfoGetFullData(VOID)
{ {
UINT32 usedSemCnt = 0; UINT32 usedSemCnt = 0;
@ -212,7 +209,7 @@ UINT32 OsSemInfoGetFullData(VOID)
} }
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
STATIC UINT32 OsSemInfoOutput(size_t semId) //用于输出信号量信息// STATIC UINT32 OsSemInfoOutput(size_t semId)
{ {
UINT32 loop, semCnt, intSave; UINT32 loop, semCnt, intSave;
LosSemCB *semCB = NULL; LosSemCB *semCB = NULL;
@ -257,7 +254,6 @@ STATIC UINT32 OsSemInfoOutput(size_t semId) //
return LOS_OK; return LOS_OK;
} }
//用于获取信号量信息//
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSemInfoGet(UINT32 argc, const CHAR **argv) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSemInfoGet(UINT32 argc, const CHAR **argv)
{ {
size_t semId; size_t semId;

61
src/kernel/base/include/los_binarytree_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义了与二叉树相关的结构体和函数，用于实现对数据的快速查找和插入。
#ifndef _LOS_BINARYTREE_PRI_H #ifndef _LOS_BINARYTREE_PRI_H
#define _LOS_BINARYTREE_PRI_H #define _LOS_BINARYTREE_PRI_H
@ -35,76 +35,67 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//定义二叉树节点的模型
typedef struct tagBinNode { typedef struct tagBinNode {
struct tagBinNode *left;//左子树节点 struct tagBinNode *left;
struct tagBinNode *right;//右子树节点 struct tagBinNode *right;
UINT32 nodeId;//节点的编号 UINT32 nodeId;
CHAR keyValue[0];//节点记录的值（柔性数组，动态分配内存） CHAR keyValue[0];
} BinNode; } BinNode;
//链接二叉树节点
typedef struct { typedef struct {
BinNode leaf;//一个二叉树 BinNode leaf;
UINTPTR linkReg1;//无符号数的指针，可连接三个节点 UINTPTR linkReg1;
UINTPTR linkReg2; UINTPTR linkReg2;
UINTPTR linkReg3; UINTPTR linkReg3;
} LinkRegNode; } LinkRegNode;
#define LR_COUNT 4096 #define LR_COUNT 4096
extern LinkRegNode g_linkRegNode[LR_COUNT];//4096个链接二叉树节点 extern LinkRegNode g_linkRegNode[LR_COUNT];
extern UINT32 g_linkRegNodeIndex;//链接二叉树节点的索引 extern UINT32 g_linkRegNodeIndex;
extern LinkRegNode *g_linkRegRoot;//链接二叉树节点的指针 extern LinkRegNode *g_linkRegRoot;
//地址二叉树节点
typedef struct { typedef struct {
BinNode leaf;//一个二叉树节点 BinNode leaf;
UINTPTR addr;//二叉树节点记录的地址 UINTPTR addr;
} AddrNode; } AddrNode;
#define ADDR_COUNT 40960 #define ADDR_COUNT 40960
extern AddrNode g_addrNode[ADDR_COUNT];//40960个地址二叉树节点 extern AddrNode g_addrNode[ADDR_COUNT];
extern UINT32 g_addrNodeIndex;//地址二叉树节点的索引 extern UINT32 g_addrNodeIndex;
extern AddrNode *g_addrRoot;//地址二叉树节点的指针 extern AddrNode *g_addrRoot;
//请求大小二叉树节点
typedef struct { typedef struct {
BinNode leaf;//一个二叉树 BinNode leaf;
UINT32 reqSize;//请求数据大小 UINT32 reqSize;
} ReqSizeNode; } ReqSizeNode;
#define REQ_SIZE_COUNT 4096 #define REQ_SIZE_COUNT 4096
extern ReqSizeNode g_reqSizeNode[REQ_SIZE_COUNT];//4096个请求大小二叉树节点 extern ReqSizeNode g_reqSizeNode[REQ_SIZE_COUNT];
extern UINT32 g_reqSizeNodeIndex;//请求大小二叉树节点的索引 extern UINT32 g_reqSizeNodeIndex;
extern ReqSizeNode *g_reqSizeRoot;//请求大小二叉树节点的指针 extern ReqSizeNode *g_reqSizeRoot;
//任务编号二叉树节点
typedef struct { typedef struct {
BinNode leaf; BinNode leaf;
UINT32 taskId; UINT32 taskId;
} TaskIDNode; } TaskIDNode;
#define TASK_ID_COUNT 1024//1024个任务编号 #define TASK_ID_COUNT 1024
//将节点插入二叉树的函数
extern UINT32 OsBinTreeInsert(const VOID *node, UINT32 nodeLen, BinNode **leaf, extern UINT32 OsBinTreeInsert(const VOID *node, UINT32 nodeLen, BinNode **leaf,
BinNode *(*GetMyBinNode)(UINT32 *nodeId), BinNode *(*GetMyBinNode)(UINT32 *nodeId),
INT32 (*CompareNode)(const VOID *node1, const VOID *node2)); INT32 (*CompareNode)(const VOID *node1, const VOID *node2));
//比较两个二叉树节点
extern INT32 OsCompareLRNode(const VOID *node1, const VOID *node2); extern INT32 OsCompareLRNode(const VOID *node1, const VOID *node2);
//通过二叉树节点的编号得到二叉树
extern BinNode *OsGetLRBinNode(UINT32 *nodeId); extern BinNode *OsGetLRBinNode(UINT32 *nodeId);
//比较两个地址二叉树节点
extern INT32 OsCompareAddrNode(const VOID *node1, const VOID *node2); extern INT32 OsCompareAddrNode(const VOID *node1, const VOID *node2);
//通过地址二叉树节点的编号得到地址二叉树
extern BinNode *OsGetAddrBinNode(UINT32 *nodeId); extern BinNode *OsGetAddrBinNode(UINT32 *nodeId);
//比较两个请求大小二叉树节点
extern INT32 OsCompareReqSizeNode(const VOID *node1, const VOID *node2); extern INT32 OsCompareReqSizeNode(const VOID *node1, const VOID *node2);
//通过请求大小二叉树节点的编号得到请求大小二叉树
extern BinNode *OsGetReqSizeBinNode(UINT32 *nodeId); extern BinNode *OsGetReqSizeBinNode(UINT32 *nodeId);
//比较两个任务编号二叉树节点
extern INT32 OsCompareTaskIDNode(const VOID *node1, const VOID *node2); extern INT32 OsCompareTaskIDNode(const VOID *node1, const VOID *node2);
//通过任务编号二叉树节点的编号得到任务编号二叉树
extern BinNode *OsGetTaskIDBinNode(UINT32 *nodeId); extern BinNode *OsGetTaskIDBinNode(UINT32 *nodeId);
#ifdef __cplusplus #ifdef __cplusplus

5
src/kernel/base/include/los_err_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//用于定义一些错误处理相关的宏和函数。
#ifndef _LOS_ERR_PRI_H #ifndef _LOS_ERR_PRI_H
#define _LOS_ERR_PRI_H #define _LOS_ERR_PRI_H
@ -40,7 +40,6 @@ extern "C" {
#define OS_ERR_MAGIC_WORD 0xa1b2c3f8 #define OS_ERR_MAGIC_WORD 0xa1b2c3f8
/* used to call the error handling function by using an error code and return the same error code. */ /* used to call the error handling function by using an error code and return the same error code. */
//通过调用处理异常的错误码返回错误码
#define OS_RETURN_ERROR(errNo) do { \ #define OS_RETURN_ERROR(errNo) do { \
(VOID)LOS_ErrHandle("os_unspecific_file", OS_ERR_MAGIC_WORD, errNo, 0, NULL); \ (VOID)LOS_ErrHandle("os_unspecific_file", OS_ERR_MAGIC_WORD, errNo, 0, NULL); \
return errNo; \ return errNo; \
@ -50,14 +49,12 @@ extern "C" {
* Call the error handling function by using an error code and the line number of * Call the error handling function by using an error code and the line number of
* the erroneous line, and return the same error code. * the erroneous line, and return the same error code.
*/ */
//通过调用异常发生行的位置返回错误码
#define OS_RETURN_ERROR_P2(errLine, errNo) do { \ #define OS_RETURN_ERROR_P2(errLine, errNo) do { \
(VOID)LOS_ErrHandle("os_unspecific_file", errLine, errNo, 0, NULL); \ (VOID)LOS_ErrHandle("os_unspecific_file", errLine, errNo, 0, NULL); \
return errNo; \ return errNo; \
} while (0) } while (0)
/* Used to call the error handling function by using an error code. */ /* Used to call the error handling function by using an error code. */
//通过错误码进行调用处理异常的函数
#define OS_GOTO_ERR_HANDLER(errorNo) do { \ #define OS_GOTO_ERR_HANDLER(errorNo) do { \
errNo = errorNo; \ errNo = errorNo; \
errLine = OS_ERR_MAGIC_WORD; \ errLine = OS_ERR_MAGIC_WORD; \

9
src/kernel/base/include/los_event_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义了一些与事件操作相关的私有函数和结构体。
#ifndef _LOS_EVENT_PRI_H #ifndef _LOS_EVENT_PRI_H
#define _LOS_EVENT_PRI_H #define _LOS_EVENT_PRI_H
@ -38,11 +38,10 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_COMPAT_POSIX #ifdef LOSCFG_COMPAT_POSIX
//定义时间状态的结构体
typedef struct { typedef struct {
volatile INT32 *realValue;//指向的是一个共享资源的计数器 volatile INT32 *realValue;
INT32 value;//条件变量的值 INT32 value;
UINT32 clearEvent;//需要清除的事件标志 UINT32 clearEvent;
} EventCond; } EventCond;
extern UINT32 OsEventReadWithCond(const EventCond *cond, PEVENT_CB_S eventCB, extern UINT32 OsEventReadWithCond(const EventCond *cond, PEVENT_CB_S eventCB,

15
src/kernel/base/include/los_exc_pri.h
Unescape View File

@ -25,14 +25,12 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义了一些与异常处理相关的私有函数和宏
//防止同一个头文件被多次包含
#ifndef _LOS_EXC_PRI_H #ifndef _LOS_EXC_PRI_H
#define _LOS_EXC_PRI_H #define _LOS_EXC_PRI_H
#include "los_exc.h" #include "los_exc.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
extern "C" { extern "C" {
@ -40,28 +38,17 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_SHELL_EXCINFO_DUMP #ifdef LOSCFG_SHELL_EXCINFO_DUMP
//用于设置异常信息读写函数的指针。
extern VOID OsSetExcInfoRW(LogReadWriteFunc func); extern VOID OsSetExcInfoRW(LogReadWriteFunc func);
extern LogReadWriteFunc OsGetExcInfoRW(VOID); extern LogReadWriteFunc OsGetExcInfoRW(VOID);
//用于设置异常信息缓冲区的指针。
extern VOID OsSetExcInfoBuf(CHAR *buf); extern VOID OsSetExcInfoBuf(CHAR *buf);
//用于获取异常信息缓冲区的指针。
extern CHAR *OsGetExcInfoBuf(VOID); extern CHAR *OsGetExcInfoBuf(VOID);
//用于设置异常信息在缓冲区中的偏移量。
extern VOID OsSetExcInfoOffset(UINT32 offset); extern VOID OsSetExcInfoOffset(UINT32 offset);
//用于获取异常信息在缓冲区中的偏移量。
extern UINT32 OsGetExcInfoOffset(VOID); extern UINT32 OsGetExcInfoOffset(VOID);
//用于设置异常信息转储地址。
extern VOID OsSetExcInfoDumpAddr(UINTPTR addr); extern VOID OsSetExcInfoDumpAddr(UINTPTR addr);
//用于获取异常信息转储地址。
extern UINTPTR OsGetExcInfoDumpAddr(VOID); extern UINTPTR OsGetExcInfoDumpAddr(VOID);
//用于设置异常信息的长度。
extern VOID OsSetExcInfoLen(UINT32 len); extern VOID OsSetExcInfoLen(UINT32 len);
//用于获取异常信息的长度。
extern UINT32 OsGetExcInfoLen(VOID); extern UINT32 OsGetExcInfoLen(VOID);
//用于记录异常信息的时间戳。
extern VOID OsRecordExcInfoTime(VOID); extern VOID OsRecordExcInfoTime(VOID);
//用于将格式化的字符串写入异常信息缓冲区。
extern VOID WriteExcBufVa(const CHAR *format, va_list arg); extern VOID WriteExcBufVa(const CHAR *format, va_list arg);
extern VOID WriteExcInfoToBuf(const CHAR *format, ...); extern VOID WriteExcInfoToBuf(const CHAR *format, ...);
#endif #endif

21
src/kernel/base/include/los_hwi_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义了一些与硬件中断处理相关的数据结构和函数接口，用于操作和管理系统中的硬件中断。
#ifndef _LOS_HWI_PRI_H #ifndef _LOS_HWI_PRI_H
#define _LOS_HWI_PRI_H #define _LOS_HWI_PRI_H
@ -67,11 +67,9 @@ typedef struct {
} HwiControllerOps; } HwiControllerOps;
extern const HwiControllerOps *g_hwiOps; extern const HwiControllerOps *g_hwiOps;
//用于初始化硬件中断
extern VOID OsHwiInit(VOID); extern VOID OsHwiInit(VOID);
//用于获取当前中断嵌套的计数值，可以用于检查当前是否处于中断嵌套状态。
extern size_t OsIrqNestingCntGet(VOID); extern size_t OsIrqNestingCntGet(VOID);
//用于设置中断嵌套的计数值。
extern VOID OsIrqNestingCntSet(size_t val); extern VOID OsIrqNestingCntSet(size_t val);
/** /**
@ -79,9 +77,8 @@ extern VOID OsIrqNestingCntSet(size_t val);
* by the kernel. The handleIrq hook function MUST be registered in the interrupt controller driver layer, otherwise it * by the kernel. The handleIrq hook function MUST be registered in the interrupt controller driver layer, otherwise it
* will not respond. eg: Used for arm(cortex-a/r)/arm64. * will not respond. eg: Used for arm(cortex-a/r)/arm64.
*/ */
//一个汇编入口函数，由汇编代码在dispatch.S中调用，用于统一处理外部中断的入口，由内核接管中断处理流程。
extern VOID OsIntEntry(VOID); extern VOID OsIntEntry(VOID);
//根据中断号获取中断处理信息的指针
STATIC INLINE HwiHandleInfo *OsGetHwiForm(UINT32 hwiNum) STATIC INLINE HwiHandleInfo *OsGetHwiForm(UINT32 hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->getHandleForm == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->getHandleForm == NULL)) {
@ -89,7 +86,7 @@ STATIC INLINE HwiHandleInfo *OsGetHwiForm(UINT32 hwiNum)
} }
return g_hwiOps->getHandleForm(hwiNum); return g_hwiOps->getHandleForm(hwiNum);
} }
//用于获取指定中断的响应计数值
STATIC INLINE UINT32 OsGetHwiFormCnt(UINT32 hwiNum) STATIC INLINE UINT32 OsGetHwiFormCnt(UINT32 hwiNum)
{ {
HwiHandleInfo *hwiForm = OsGetHwiForm(hwiNum); HwiHandleInfo *hwiForm = OsGetHwiForm(hwiNum);
@ -99,7 +96,7 @@ STATIC INLINE UINT32 OsGetHwiFormCnt(UINT32 hwiNum)
} }
return hwiForm->respCount; return hwiForm->respCount;
} }
//用于获取当前正在处理的中断号。
STATIC INLINE UINT32 OsIntNumGet(VOID) STATIC INLINE UINT32 OsIntNumGet(VOID)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->getCurIrqNum == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->getCurIrqNum == NULL)) {
@ -107,7 +104,7 @@ STATIC INLINE UINT32 OsIntNumGet(VOID)
} }
return g_hwiOps->getCurIrqNum(); return g_hwiOps->getCurIrqNum();
} }
//用于判断指定的中断号是否已经注册了相应的处理函数。
STATIC INLINE BOOL OsIntIsRegisted(UINT32 num) STATIC INLINE BOOL OsIntIsRegisted(UINT32 num)
{ {
HwiHandleInfo *hwiForm = OsGetHwiForm(num); HwiHandleInfo *hwiForm = OsGetHwiForm(num);
@ -121,7 +118,7 @@ STATIC INLINE BOOL OsIntIsRegisted(UINT32 num)
return (hwiForm->hook != NULL); return (hwiForm->hook != NULL);
#endif #endif
} }
//用于获取指定中断的注册参数信息。
STATIC INLINE HWI_ARG_T OsIntGetPara(UINT32 num) STATIC INLINE HWI_ARG_T OsIntGetPara(UINT32 num)
{ {
HwiHandleInfo *hwiForm = OsGetHwiForm(num); HwiHandleInfo *hwiForm = OsGetHwiForm(num);
@ -131,7 +128,7 @@ STATIC INLINE HWI_ARG_T OsIntGetPara(UINT32 num)
} }
return hwiForm->registerInfo; return hwiForm->registerInfo;
} }
//用于获取中断版本信息。
STATIC INLINE CHAR *OsIntVersionGet(VOID) STATIC INLINE CHAR *OsIntVersionGet(VOID)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->getIrqVersion == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->getIrqVersion == NULL)) {
@ -146,7 +143,6 @@ STATIC INLINE CHAR *OsIntVersionGet(VOID)
* handleForm to this interface. * handleForm to this interface.
* eg: Used for arm(cortex-m),xtensa,riscv. * eg: Used for arm(cortex-m),xtensa,riscv.
*/ */
//在中断控制器驱动层实现通用的中断处理入口，用于传递中断号和处理信息给相应的处理函数。
extern VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *handleForm); extern VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *handleForm);
/** /**
@ -155,7 +151,6 @@ extern VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *handleForm);
* HwiControllerOps need to be registered. If this function is not supported, you can call the LOS_Panic interface in * HwiControllerOps need to be registered. If this function is not supported, you can call the LOS_Panic interface in
* the implementation of the stub function to report an error in time. * the implementation of the stub function to report an error in time.
*/ */
//用于注册中断控制器相关的操作函数，需要在中断控制器初始化时被调用。
STATIC INLINE VOID OsHwiControllerReg(const HwiControllerOps *ops) STATIC INLINE VOID OsHwiControllerReg(const HwiControllerOps *ops)
{ {
g_hwiOps = ops; g_hwiOps = ops;

2
src/kernel/base/include/los_membox_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件的作用是定义了与内存池相关的私有函数和数据结构。
#ifndef _LOS_MEMBOX_PRI_H #ifndef _LOS_MEMBOX_PRI_H
#define _LOS_MEMBOX_PRI_H #define _LOS_MEMBOX_PRI_H

16
src/kernel/base/include/los_memory_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义内存管理的私有接口和数据结构。
#ifndef _LOS_MEMORY_PRI_H #ifndef _LOS_MEMORY_PRI_H
#define _LOS_MEMORY_PRI_H #define _LOS_MEMORY_PRI_H
@ -35,8 +35,6 @@
#include "los_spinlock.h" #include "los_spinlock.h"
#include "los_misc_pri.h" #include "los_misc_pri.h"
//关于内存管理的私有接口声明
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
extern "C" { extern "C" {
@ -62,7 +60,6 @@ typedef struct {
struct LosSlabControlHeader slabCtrlHdr; struct LosSlabControlHeader slabCtrlHdr;
#endif #endif
} LosMemPoolInfo; } LosMemPoolInfo;
//用于描述内存池的信息，包括内存池的起始地址、大小等信息。
#elif defined(LOSCFG_KERNEL_MEM_BESTFIT_LITTLE) #elif defined(LOSCFG_KERNEL_MEM_BESTFIT_LITTLE)
@ -93,7 +90,6 @@ extern SPIN_LOCK_S g_memSpin;
#define MEM_LOCK(state) LOS_SpinLockSave(&g_memSpin, &(state)) #define MEM_LOCK(state) LOS_SpinLockSave(&g_memSpin, &(state))
#define MEM_UNLOCK(state) LOS_SpinUnlockRestore(&g_memSpin, (state)) #define MEM_UNLOCK(state) LOS_SpinUnlockRestore(&g_memSpin, (state))
//用于系统内存的初始化。
extern UINTPTR g_sys_mem_addr_end; extern UINTPTR g_sys_mem_addr_end;
extern UINT32 OsMemSystemInit(UINTPTR memStart); extern UINT32 OsMemSystemInit(UINTPTR memStart);
@ -108,12 +104,11 @@ extern UINT32 OsMemMulPoolInit(VOID *pool, UINT32 size);
extern UINT32 OsMemMulPoolDeinit(const VOID *pool); extern UINT32 OsMemMulPoolDeinit(const VOID *pool);
extern VOID *OsMemMulPoolHeadGet(VOID); extern VOID *OsMemMulPoolHeadGet(VOID);
#else /* LOSCFG_MEM_MUL_POOL */ #else /* LOSCFG_MEM_MUL_POOL */
//用于初始化多内存池，接受内存池的起始地址和大小作为参数。
STATIC INLINE UINT32 OsMemMulPoolInit(VOID *pool, UINT32 size) STATIC INLINE UINT32 OsMemMulPoolInit(VOID *pool, UINT32 size)
{ {
return LOS_OK; return LOS_OK;
} }
//用于反初始化多内存池，接受内存池的指针作为参数。
STATIC INLINE UINT32 OsMemMulPoolDeinit(const VOID *pool) STATIC INLINE UINT32 OsMemMulPoolDeinit(const VOID *pool)
{ {
return LOS_OK; return LOS_OK;
@ -121,21 +116,16 @@ STATIC INLINE UINT32 OsMemMulPoolDeinit(const VOID *pool)
#endif /* LOSCFG_MEM_MUL_POOL */ #endif /* LOSCFG_MEM_MUL_POOL */
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
//于初始化内存异常交互，接受内存起始地址作为参数。
extern UINT32 OsMemExcInteractionInit(UINTPTR memStart); extern UINT32 OsMemExcInteractionInit(UINTPTR memStart);
#endif #endif
#ifdef LOSCFG_MEM_LEAKCHECK #ifdef LOSCFG_MEM_LEAKCHECK
//用于展示已使用的内存节点信息，接受内存池指针作为参数。
extern VOID OsMemUsedNodeShow(VOID *pool); extern VOID OsMemUsedNodeShow(VOID *pool);
#endif #endif
//用于重置内存池的结束节点，接受内存池指针和前一个地址作为参数。
extern VOID OsMemResetEndNode(VOID *pool, UINTPTR preAddr); extern VOID OsMemResetEndNode(VOID *pool, UINTPTR preAddr);
//用于打印内存信息，接受内存池指针作为参数。
extern VOID OsMemInfoPrint(const VOID *pool); extern VOID OsMemInfoPrint(const VOID *pool);
//用于执行内存检查的 shell 命令，接受命令参数作为输入。
extern UINT32 OsShellCmdMemCheck(INT32 argc, const CHAR *argv[]); extern UINT32 OsShellCmdMemCheck(INT32 argc, const CHAR *argv[]);
//用于执行多重内存完整性检查。
extern VOID OsMemIntegrityMultiCheck(VOID); extern VOID OsMemIntegrityMultiCheck(VOID);
#ifdef __cplusplus #ifdef __cplusplus

21
src/kernel/base/include/los_memstat_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义了一些用于内存统计的数据结构和函数接口，用于跟踪和管理任务使用的内存情况。
#ifndef _LOS_MEMSTAT_PRI_H #ifndef _LOS_MEMSTAT_PRI_H
#define _LOS_MEMSTAT_PRI_H #define _LOS_MEMSTAT_PRI_H
@ -43,22 +43,19 @@ extern "C" {
#ifdef LOSCFG_MEM_TASK_STAT #ifdef LOSCFG_MEM_TASK_STAT
typedef struct { typedef struct {
UINT32 memUsed;//内存使用 UINT32 memUsed;
UINT32 memPeak;//内存峰值 UINT32 memPeak;
} TaskMemUsedInfo; } TaskMemUsedInfo;
typedef struct { typedef struct {
UINT32 memTotalUsed;//内存使用量 UINT32 memTotalUsed;
UINT32 memTotalPeak;//内存使用峰值 UINT32 memTotalPeak;
TaskMemUsedInfo taskMemstats[TASK_NUM];//使用内存的任务列表 TaskMemUsedInfo taskMemstats[TASK_NUM];
} Memstat; } Memstat;
//用于增加任务的内存使用量和峰值。
extern VOID OsMemstatTaskUsedInc(Memstat *stat, UINT32 usedSize, UINT32 taskId); extern VOID OsMemstatTaskUsedInc(Memstat *stat, UINT32 usedSize, UINT32 taskId);
//用于减少任务的内存使用量和峰值。
extern VOID OsMemstatTaskUsedDec(Memstat *stat, UINT32 usedSize, UINT32 taskId); extern VOID OsMemstatTaskUsedDec(Memstat *stat, UINT32 usedSize, UINT32 taskId);
//用于清除任务的内存统计信息。
extern VOID OsMemstatTaskClear(Memstat *stat, UINT32 taskId); extern VOID OsMemstatTaskClear(Memstat *stat, UINT32 taskId);
//用于获取任务的内存使用率。
extern UINT32 OsMemstatTaskUsage(const Memstat *stat, UINT32 taskId); extern UINT32 OsMemstatTaskUsage(const Memstat *stat, UINT32 taskId);
#endif #endif
@ -66,13 +63,9 @@ extern VOID OsMemTaskClear(UINT32 taskId);
extern UINT32 OsMemTaskUsage(UINT32 taskId); extern UINT32 OsMemTaskUsage(UINT32 taskId);
#ifdef LOSCFG_MEM_TASK_STAT #ifdef LOSCFG_MEM_TASK_STAT
//增加任务的内存使用量和峰值。
#define OS_MEM_ADD_USED(stat, usedSize, taskId) OsMemstatTaskUsedInc(stat, usedSize, taskId) #define OS_MEM_ADD_USED(stat, usedSize, taskId) OsMemstatTaskUsedInc(stat, usedSize, taskId)
//减少任务的内存使用量和峰值。
#define OS_MEM_REDUCE_USED(stat, usedSize, taskId) OsMemstatTaskUsedDec(stat, usedSize, taskId) #define OS_MEM_REDUCE_USED(stat, usedSize, taskId) OsMemstatTaskUsedDec(stat, usedSize, taskId)
//清除任务的内存统计信息。
#define OS_MEM_CLEAR(taskId) OsMemTaskClear(taskId) #define OS_MEM_CLEAR(taskId) OsMemTaskClear(taskId)
//获取任务的内存使用率。
#define OS_MEM_USAGE(taskId) OsMemTaskUsage(taskId) #define OS_MEM_USAGE(taskId) OsMemTaskUsage(taskId)
#else #else
#define OS_MEM_ADD_USED(stat, usedSize, taskId) #define OS_MEM_ADD_USED(stat, usedSize, taskId)

7
src/kernel/base/include/los_misc_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义了一些私有接口和数据结构，主要涉及与内存相关的功能和调试功能。
#ifndef _LOS_MISC_PRI_H #ifndef _LOS_MISC_PRI_H
#define _LOS_MISC_PRI_H #define _LOS_MISC_PRI_H
@ -36,7 +36,7 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//定义了一个用于将指定地址开始的连续内存字节进行转储的函数。可以用于调试和观察内存中的数据。
VOID OsDumpMemByte(size_t length, UINTPTR addr); VOID OsDumpMemByte(size_t length, UINTPTR addr);
#if defined(LOSCFG_DEBUG_SEMAPHORE) || defined(LOSCFG_DEBUG_MUTEX) || defined(LOSCFG_DEBUG_QUEUE) #if defined(LOSCFG_DEBUG_SEMAPHORE) || defined(LOSCFG_DEBUG_MUTEX) || defined(LOSCFG_DEBUG_QUEUE)
@ -48,16 +48,13 @@ typedef struct {
} SortParam; } SortParam;
/* Compare the size of the last access time */ /* Compare the size of the last access time */
//用于排序时比较控制块成员的大小。
typedef BOOL (*OsCompareFunc)(const SortParam *sortParam, UINT32 left, UINT32 right); typedef BOOL (*OsCompareFunc)(const SortParam *sortParam, UINT32 left, UINT32 right);
/* Get the address of the comparison member variable */ /* Get the address of the comparison member variable */
//用于获取控制块成员变量的地址。
#define SORT_ELEM_ADDR(sortParam, index) \ #define SORT_ELEM_ADDR(sortParam, index) \
((sortParam)->buf + ((index) * (sortParam)->ctrlBlockSize) + (sortParam)->sortElemOff) ((sortParam)->buf + ((index) * (sortParam)->ctrlBlockSize) + (sortParam)->sortElemOff)
/* Sort this index array. */ /* Sort this index array. */
//用于对索引数组进行排序。
extern VOID OsArraySort(UINT32 *sortArray, UINT32 start, UINT32 end, const SortParam *sortParam, extern VOID OsArraySort(UINT32 *sortArray, UINT32 start, UINT32 end, const SortParam *sortParam,
OsCompareFunc compareFunc); OsCompareFunc compareFunc);
#endif #endif

10
src/kernel/base/include/los_mp_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//定义了一些私有接口、数据结构和宏，主要涉及多处理器（MP）相关的功能。
#ifndef _LOS_MP_PRI_H #ifndef _LOS_MP_PRI_H
#define _LOS_MP_PRI_H #define _LOS_MP_PRI_H
@ -56,15 +56,10 @@ typedef enum {
typedef VOID (*SMP_FUNC_CALL)(VOID *args); typedef VOID (*SMP_FUNC_CALL)(VOID *args);
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
//定义了一个用于在多处理器系统中切换调度目标的函数。
extern VOID LOS_MpSchedule(UINT32 target); extern VOID LOS_MpSchedule(UINT32 target);
//定义了一个用于处理多处理器唤醒事件的函数。
extern VOID OsMpWakeHandler(VOID); extern VOID OsMpWakeHandler(VOID);
//定义了一个用于处理多处理器调度事件的函数。
extern VOID OsMpScheduleHandler(VOID); extern VOID OsMpScheduleHandler(VOID);
//定义了一个用于处理多处理器停机事件的函数。
extern VOID OsMpHaltHandler(VOID); extern VOID OsMpHaltHandler(VOID);
//定义了一个用于初始化多处理器相关功能的函数。
extern UINT32 OsMpInit(VOID); extern UINT32 OsMpInit(VOID);
#else #else
STATIC INLINE VOID LOS_MpSchedule(UINT32 target) STATIC INLINE VOID LOS_MpSchedule(UINT32 target)
@ -74,7 +69,7 @@ STATIC INLINE VOID LOS_MpSchedule(UINT32 target)
#endif #endif
#ifdef LOSCFG_KERNEL_SMP_CALL #ifdef LOSCFG_KERNEL_SMP_CALL
//用于在目标 CPU 上调用函数
typedef struct { typedef struct {
LOS_DL_LIST node; LOS_DL_LIST node;
SMP_FUNC_CALL func; SMP_FUNC_CALL func;
@ -87,7 +82,6 @@ typedef struct {
extern VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args); extern VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args);
extern VOID OsMpFuncCallHandler(VOID); extern VOID OsMpFuncCallHandler(VOID);
#else #else
//用于处理多处理器函数调用事件。
STATIC INLINE VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args) STATIC INLINE VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args)
{ {
(VOID)target; (VOID)target;

15
src/kernel/base/include/los_multipledlinkhead_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件定义了一个多重双向链表头的私有接口和数据结构。
#ifndef _LOS_MULTIPLE_DLINK_HEAD_PRI_H #ifndef _LOS_MULTIPLE_DLINK_HEAD_PRI_H
#define _LOS_MULTIPLE_DLINK_HEAD_PRI_H #define _LOS_MULTIPLE_DLINK_HEAD_PRI_H
@ -37,30 +37,25 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//表示最大的多重双向链表的大小的对数值。
#define OS_MAX_MULTI_DLNK_LOG2 29 #define OS_MAX_MULTI_DLNK_LOG2 29
//表示最小的多重双向链表的大小的对数值。
#define OS_MIN_MULTI_DLNK_LOG2 4 #define OS_MIN_MULTI_DLNK_LOG2 4
//表示多重双向链表的数量，通过最大和最小的对数值计算得到。
#define OS_MULTI_DLNK_NUM ((OS_MAX_MULTI_DLNK_LOG2 - OS_MIN_MULTI_DLNK_LOG2) + 1) #define OS_MULTI_DLNK_NUM ((OS_MAX_MULTI_DLNK_LOG2 - OS_MIN_MULTI_DLNK_LOG2) + 1)
//表示多重双向链表头的大小。
#define OS_DLNK_HEAD_SIZE OS_MULTI_DLNK_HEAD_SIZE #define OS_DLNK_HEAD_SIZE OS_MULTI_DLNK_HEAD_SIZE
//表示多重双向链表头结构体的大小。
#define OS_MULTI_DLNK_HEAD_SIZE sizeof(LosMultipleDlinkHead) #define OS_MULTI_DLNK_HEAD_SIZE sizeof(LosMultipleDlinkHead)
//用于存储多重双向链表的头指针数组。
typedef struct { typedef struct {
LOS_DL_LIST listHead[OS_MULTI_DLNK_NUM]; LOS_DL_LIST listHead[OS_MULTI_DLNK_NUM];
} LosMultipleDlinkHead; } LosMultipleDlinkHead;
//根据给定的头地址和链表节点头指针，返回下一个多重链表的头指针。
STATIC INLINE LOS_DL_LIST *OsDLnkNextMultiHead(VOID *headAddr, LOS_DL_LIST *listNodeHead) STATIC INLINE LOS_DL_LIST *OsDLnkNextMultiHead(VOID *headAddr, LOS_DL_LIST *listNodeHead)
{ {
LosMultipleDlinkHead *head = (LosMultipleDlinkHead *)headAddr; LosMultipleDlinkHead *head = (LosMultipleDlinkHead *)headAddr;
return (&head->listHead[OS_MULTI_DLNK_NUM - 1] == listNodeHead) ? NULL : (listNodeHead + 1); return (&head->listHead[OS_MULTI_DLNK_NUM - 1] == listNodeHead) ? NULL : (listNodeHead + 1);
} }
//对给定的头地址进行初始化，将多重双向链表的头指针数组中的所有指针置为 NULL。
extern VOID OsDLnkInitMultiHead(VOID *headAddr); extern VOID OsDLnkInitMultiHead(VOID *headAddr);
//根据给定的头地址和大小，返回对应的多重双向链表的头指针。
extern LOS_DL_LIST *OsDLnkMultiHead(VOID *headAddr, UINT32 size); extern LOS_DL_LIST *OsDLnkMultiHead(VOID *headAddr, UINT32 size);
#ifdef __cplusplus #ifdef __cplusplus

14
src/kernel/base/include/los_mux_debug_pri.h
Unescape View File

@ -26,9 +26,6 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这个头文件定义了一些用于互斥锁（mutex）调试的接口和函数，包括死锁检测、互斥锁状态跟踪、互斥锁泄漏检查等。
这些接口和函数主要用于开发人员在调试过程中分析互斥锁的使用情况，帮助找出潜在的问题并解决它们。*/
#ifndef _LOS_MUX_DEBUG_PRI_H #ifndef _LOS_MUX_DEBUG_PRI_H
#define _LOS_MUX_DEBUG_PRI_H #define _LOS_MUX_DEBUG_PRI_H
@ -38,7 +35,7 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//初始化死锁检测机制
/* Deadlock detection initialization interface */ /* Deadlock detection initialization interface */
extern UINT32 OsMuxDlockCheckInit(VOID); extern UINT32 OsMuxDlockCheckInit(VOID);
STATIC INLINE UINT32 OsMuxDlockCheckInitHook(VOID) STATIC INLINE UINT32 OsMuxDlockCheckInitHook(VOID)
@ -49,7 +46,7 @@ STATIC INLINE UINT32 OsMuxDlockCheckInitHook(VOID)
return LOS_OK; return LOS_OK;
#endif #endif
} }
//向死锁检测机制中添加任务持有的互斥锁信息
/* Add holding mutex lock node information */ /* Add holding mutex lock node information */
extern VOID OsMuxDlockNodeInsert(UINT32 taskId, VOID *muxCB); extern VOID OsMuxDlockNodeInsert(UINT32 taskId, VOID *muxCB);
STATIC INLINE VOID OsMuxDlockNodeInsertHook(UINT32 taskId, VOID *muxCB) STATIC INLINE VOID OsMuxDlockNodeInsertHook(UINT32 taskId, VOID *muxCB)
@ -58,7 +55,6 @@ STATIC INLINE VOID OsMuxDlockNodeInsertHook(UINT32 taskId, VOID *muxCB)
OsMuxDlockNodeInsert(taskId, muxCB); OsMuxDlockNodeInsert(taskId, muxCB);
#endif #endif
} }
//从死锁检测机制中删除任务持有的互斥锁信息
/* Delete holding mutex lock node information */ /* Delete holding mutex lock node information */
extern VOID OsMuxDlockNodeDelete(UINT32 taskId, const VOID *muxCB); extern VOID OsMuxDlockNodeDelete(UINT32 taskId, const VOID *muxCB);
STATIC INLINE VOID OsMuxDlockNodeDeleteHook(UINT32 taskId, const VOID *muxCB) STATIC INLINE VOID OsMuxDlockNodeDeleteHook(UINT32 taskId, const VOID *muxCB)
@ -67,7 +63,6 @@ STATIC INLINE VOID OsMuxDlockNodeDeleteHook(UINT32 taskId, const VOID *muxCB)
OsMuxDlockNodeDelete(taskId, muxCB); OsMuxDlockNodeDelete(taskId, muxCB);
#endif #endif
} }
//更新任务最后执行的时间
/* Update the last time the task was executed */ /* Update the last time the task was executed */
extern VOID OsTaskTimeUpdate(UINT32 taskId, UINT64 tickCount); extern VOID OsTaskTimeUpdate(UINT32 taskId, UINT64 tickCount);
STATIC INLINE VOID OsTaskTimeUpdateHook(UINT32 taskId, UINT64 tickCount) STATIC INLINE VOID OsTaskTimeUpdateHook(UINT32 taskId, UINT64 tickCount)
@ -76,7 +71,7 @@ STATIC INLINE VOID OsTaskTimeUpdateHook(UINT32 taskId, UINT64 tickCount)
OsTaskTimeUpdate(taskId, tickCount); OsTaskTimeUpdate(taskId, tickCount);
#endif #endif
} }
//初始化互斥锁状态跟踪机制
/* mutex debug initialization interface */ /* mutex debug initialization interface */
extern UINT32 OsMuxDbgInit(VOID); extern UINT32 OsMuxDbgInit(VOID);
STATIC INLINE UINT32 OsMuxDbgInitHook(VOID) STATIC INLINE UINT32 OsMuxDbgInitHook(VOID)
@ -87,7 +82,6 @@ STATIC INLINE UINT32 OsMuxDbgInitHook(VOID)
return LOS_OK; return LOS_OK;
#endif #endif
} }
//更新互斥锁最后执行的时间
/* Update the last time the mutex was executed */ /* Update the last time the mutex was executed */
extern VOID OsMuxDbgTimeUpdate(UINT32 muxId); extern VOID OsMuxDbgTimeUpdate(UINT32 muxId);
STATIC INLINE VOID OsMuxDbgTimeUpdateHook(UINT32 muxId) STATIC INLINE VOID OsMuxDbgTimeUpdateHook(UINT32 muxId)
@ -96,7 +90,6 @@ STATIC INLINE VOID OsMuxDbgTimeUpdateHook(UINT32 muxId)
OsMuxDbgTimeUpdate(muxId); OsMuxDbgTimeUpdate(muxId);
#endif #endif
} }
//在创建或删除互斥锁时更新互斥锁的状态跟踪信息
/* Update the MUX_DEBUG_CB of the mutex when created or deleted */ /* Update the MUX_DEBUG_CB of the mutex when created or deleted */
extern VOID OsMuxDbgUpdate(UINT32 muxID, TSK_ENTRY_FUNC creator); extern VOID OsMuxDbgUpdate(UINT32 muxID, TSK_ENTRY_FUNC creator);
STATIC INLINE VOID OsMuxDbgUpdateHook(UINT32 muxId, TSK_ENTRY_FUNC creator) STATIC INLINE VOID OsMuxDbgUpdateHook(UINT32 muxId, TSK_ENTRY_FUNC creator)
@ -105,7 +98,6 @@ STATIC INLINE VOID OsMuxDbgUpdateHook(UINT32 muxId, TSK_ENTRY_FUNC creator)
OsMuxDbgUpdate(muxId, creator); OsMuxDbgUpdate(muxId, creator);
#endif #endif
} }
//检查互斥锁是否泄漏
/* check the leak of mutex */ /* check the leak of mutex */
extern VOID OsMutexCheck(VOID); extern VOID OsMutexCheck(VOID);
STATIC INLINE VOID OsMutexCheckHook(VOID) STATIC INLINE VOID OsMutexCheckHook(VOID)

19
src/kernel/base/include/los_mux_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//一个关于互斥锁的内部实现的头文件
#ifndef _LOS_MUX_PRI_H #ifndef _LOS_MUX_PRI_H
#define _LOS_MUX_PRI_H #define _LOS_MUX_PRI_H
@ -45,13 +45,12 @@ extern "C" {
* Mutex base object must be the same as the first three member names of LosMuxCB, * Mutex base object must be the same as the first three member names of LosMuxCB,
* so that pthread_mutex_t can share the kernel mutex mechanism. * so that pthread_mutex_t can share the kernel mutex mechanism.
*/ */
//这是互斥锁的基本控制块，包含了互斥锁的一些基本信息
typedef struct { typedef struct {
LOS_DL_LIST muxList;//连接列表 /* Mutex linked list */ LOS_DL_LIST muxList; /* Mutex linked list */
LosTaskCB *owner; //互斥锁的拥有者 /* The current thread that is locking a mutex */ LosTaskCB *owner; /* The current thread that is locking a mutex */
UINT16 muxCount; //被锁定的次数 /* Times of locking a mutex */ UINT16 muxCount; /* Times of locking a mutex */
} MuxBaseCB; } MuxBaseCB;
//这是互斥锁的控制块，包含了更多的互斥锁信息
typedef struct { typedef struct {
LOS_DL_LIST muxList; /* Mutex linked list */ LOS_DL_LIST muxList; /* Mutex linked list */
LosTaskCB *owner; /* The current thread that is locking a mutex */ LosTaskCB *owner; /* The current thread that is locking a mutex */
@ -61,29 +60,21 @@ typedef struct {
} LosMuxCB; } LosMuxCB;
/* Mutex global array address, which can be obtained by using a handle ID. */ /* Mutex global array address, which can be obtained by using a handle ID. */
//全局变量：这是一个互斥锁的全局数组地址，可以通过互斥锁的 ID 来获取对应的互斥锁对象。
extern LosMuxCB *g_allMux; extern LosMuxCB *g_allMux;
/* COUNT | INDEX split bit */ /* COUNT | INDEX split bit */
#define MUX_SPLIT_BIT 16 #define MUX_SPLIT_BIT 16
/* Set the mutex id */ /* Set the mutex id */
//设置互斥锁的 ID
#define SET_MUX_ID(count, muxId) (((count) << MUX_SPLIT_BIT) | (muxId)) #define SET_MUX_ID(count, muxId) (((count) << MUX_SPLIT_BIT) | (muxId))
//根据互斥锁的 ID 获取索引
#define GET_MUX_INDEX(muxId) ((muxId) & ((1U << MUX_SPLIT_BIT) - 1)) #define GET_MUX_INDEX(muxId) ((muxId) & ((1U << MUX_SPLIT_BIT) - 1))
//根据互斥锁的 ID 获取计数值
#define GET_MUX_COUNT(muxId) ((muxId) >> MUX_SPLIT_BIT) #define GET_MUX_COUNT(muxId) ((muxId) >> MUX_SPLIT_BIT)
/* Obtain the pointer to a mutex object of the mutex that has a specified handle. */ /* Obtain the pointer to a mutex object of the mutex that has a specified handle. */
//根据互斥锁的 ID 获取对应的互斥锁对象指针
#define GET_MUX(muxId) (((LosMuxCB *)g_allMux) + GET_MUX_INDEX(muxId)) #define GET_MUX(muxId) (((LosMuxCB *)g_allMux) + GET_MUX_INDEX(muxId))
//初始化互斥锁
extern UINT32 OsMuxInit(VOID); extern UINT32 OsMuxInit(VOID);
//执行互斥锁的等待操作
extern UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UINT32 timeout, UINT32 *intSave); extern UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UINT32 timeout, UINT32 *intSave);
//执行互斥锁的释放操作
extern UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted); extern UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted);
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus

23
src/kernel/base/include/los_percpu_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件定义了关于每个CPU的私有数据结构，这个结构体存储了与每个 CPU 相关的一些信息。
#ifndef _LOS_PERCPU_PRI_H #ifndef _LOS_PERCPU_PRI_H
#define _LOS_PERCPU_PRI_H #define _LOS_PERCPU_PRI_H
@ -47,34 +47,35 @@ typedef enum {
CPU_EXC /* cpu in the exc */ CPU_EXC /* cpu in the exc */
} ExcFlag; } ExcFlag;
#endif #endif
//排序链表的属性结构体，用于表示任务链表和软件定时器链表
typedef struct { typedef struct {
SortLinkAttribute taskSortLink; /* task sort link */ SortLinkAttribute taskSortLink; /* task sort link */
#ifdef LOSCFG_BASE_CORE_SWTMR #ifdef LOSCFG_BASE_CORE_SWTMR
SortLinkAttribute swtmrSortLink; /* swtmr sort link */ SortLinkAttribute swtmrSortLink; /* swtmr sort link */
#endif #endif
UINT32 idleTaskId;//空闲任务的任务 ID /* idle task id */ UINT32 idleTaskId; /* idle task id */
UINT32 taskLockCnt;//任务锁计数，用于标记任务是否被锁定 /* task lock flag */ UINT32 taskLockCnt; /* task lock flag */
UINT32 swtmrHandlerQueue;//软件定时器的超时队列 ID /* software timer timeout queue id */ UINT32 swtmrHandlerQueue; /* software timer timeout queue id */
UINT32 swtmrTaskId;//软件定时器任务的 ID /* software timer task id */ UINT32 swtmrTaskId; /* software timer task id */
UINT32 schedFlag;//调度标志，用于表示是否需要进行调度 /* pending scheduler flag */
UINT32 schedFlag; /* pending scheduler flag */
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
UINT32 excFlag;//CPU 异常标志，用于表示 CPU 的运行状态，包括运行、休眠和异常状态 /* cpu halt or exc flag */ UINT32 excFlag; /* cpu halt or exc flag */
#ifdef LOSCFG_KERNEL_SMP_CALL #ifdef LOSCFG_KERNEL_SMP_CALL
LOS_DL_LIST funcLink;//多处理器函数调用链表，用于多处理器间的函数调用 /* mp function call link */ LOS_DL_LIST funcLink; /* mp function call link */
#endif #endif
#endif #endif
} Percpu; } Percpu;
/* the kernel per-cpu structure */ /* the kernel per-cpu structure */
extern Percpu g_percpu[LOSCFG_KERNEL_CORE_NUM]; extern Percpu g_percpu[LOSCFG_KERNEL_CORE_NUM];
//用于获取当前CPU
STATIC INLINE Percpu *OsPercpuGet(VOID) STATIC INLINE Percpu *OsPercpuGet(VOID)
{ {
return &g_percpu[ArchCurrCpuid()]; return &g_percpu[ArchCurrCpuid()];
} }
//用于获取指定CPU的Percpu结构体指针
STATIC INLINE Percpu *OsPercpuGetByID(UINT32 cpuid) STATIC INLINE Percpu *OsPercpuGetByID(UINT32 cpuid)
{ {
return &g_percpu[cpuid]; return &g_percpu[cpuid];

9
src/kernel/base/include/los_printf_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//关于打印函数的私有头文件
#ifndef _LOS_PRINTF_PRI_H #ifndef _LOS_PRINTF_PRI_H
#define _LOS_PRINTF_PRI_H #define _LOS_PRINTF_PRI_H
@ -36,16 +36,13 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//在控制台上打印格式化字符串
extern VOID ConsoleVprintf(const CHAR *fmt, va_list ap); extern VOID ConsoleVprintf(const CHAR *fmt, va_list ap);
//在串口上打印格式化字符串
extern VOID UartVprintf(const CHAR *fmt, va_list ap); extern VOID UartVprintf(const CHAR *fmt, va_list ap);
//打印异常信息
extern VOID PrintExcInfo(const CHAR *fmt, ...); extern VOID PrintExcInfo(const CHAR *fmt, ...);
//打印内核调试信息
extern VOID LkDprintf(const CHAR *fmt, va_list ap); extern VOID LkDprintf(const CHAR *fmt, va_list ap);
#ifdef LOSCFG_SHELL_DMESG #ifdef LOSCFG_SHELL_DMESG
//打印系统日志信息
extern VOID DmesgPrintf(const CHAR *fmt, va_list ap); extern VOID DmesgPrintf(const CHAR *fmt, va_list ap);
#endif #endif

10
src/kernel/base/include/los_priqueue_pri.h
Unescape View File

@ -25,8 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这个头文件定义了优先级队列的相关操作函数，
包括初始化优先级队列、插入项目到优先级队列、从优先级队列中删除项目、获取具有最高优先级的项目等*/
#ifndef _LOS_PRIQUEUE_PRI_H #ifndef _LOS_PRIQUEUE_PRI_H
#define _LOS_PRIQUEUE_PRI_H #define _LOS_PRIQUEUE_PRI_H
@ -58,7 +57,6 @@ extern "C" {
* @see none. * @see none.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//初始化优先级队列
extern UINT32 OsPriQueueInit(VOID); extern UINT32 OsPriQueueInit(VOID);
/** /**
@ -81,7 +79,6 @@ extern UINT32 OsPriQueueInit(VOID);
* @see OsPriQueueDequeue. * @see OsPriQueueDequeue.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//根据项目的优先级将项目插入到优先级队列中
extern VOID OsPriQueueEnqueue(LOS_DL_LIST *priqueueItem, UINT32 priority); extern VOID OsPriQueueEnqueue(LOS_DL_LIST *priqueueItem, UINT32 priority);
/** /**
@ -102,7 +99,6 @@ extern VOID OsPriQueueEnqueue(LOS_DL_LIST *priqueueItem, UINT32 priority);
* @see OsPriQueueEnqueue. * @see OsPriQueueEnqueue.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//从优先级队列中删除一个项目
extern VOID OsPriQueueDequeue(LOS_DL_LIST *priqueueItem); extern VOID OsPriQueueDequeue(LOS_DL_LIST *priqueueItem);
/** /**
@ -124,7 +120,6 @@ extern VOID OsPriQueueDequeue(LOS_DL_LIST *priqueueItem);
* @see none. * @see none.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//获取优先级队列中具有最高优先级的项目
extern LOS_DL_LIST *OsPriQueueTop(VOID); extern LOS_DL_LIST *OsPriQueueTop(VOID);
/** /**
@ -145,7 +140,6 @@ extern LOS_DL_LIST *OsPriQueueTop(VOID);
* @see none. * @see none.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//获取具有指定优先级的项目数量
extern UINT32 OsPriQueueSize(UINT32 priority); extern UINT32 OsPriQueueSize(UINT32 priority);
/** /**
@ -165,7 +159,6 @@ extern UINT32 OsPriQueueSize(UINT32 priority);
* @see none. * @see none.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//获取优先级队列中项目的总数
extern UINT32 OsPriQueueTotalSize(VOID); extern UINT32 OsPriQueueTotalSize(VOID);
/** /**
@ -188,7 +181,6 @@ extern UINT32 OsPriQueueTotalSize(VOID);
* @see OsPriQueueDequeue. * @see OsPriQueueDequeue.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//根据项目的优先级将项目插入到优先级队列的头部
extern VOID OsPriQueueEnqueueHead(LOS_DL_LIST *priqueueItem, UINT32 priority); extern VOID OsPriQueueEnqueueHead(LOS_DL_LIST *priqueueItem, UINT32 priority);
#ifdef __cplusplus #ifdef __cplusplus

10
src/kernel/base/include/los_queue_debug_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件提供了针对队列调试的相关函数声明
#ifndef _LOS_QUEUE_DEBUG_PRI_H #ifndef _LOS_QUEUE_DEBUG_PRI_H
#define _LOS_QUEUE_DEBUG_PRI_H #define _LOS_QUEUE_DEBUG_PRI_H
@ -40,9 +40,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* queue debug initialization interface */ /* queue debug initialization interface */
//队列调试初始化接口
extern UINT32 OsQueueDbgInit(VOID); extern UINT32 OsQueueDbgInit(VOID);
//队列调试初始化的钩子函数，根据配置是否开启队列调试功能来调用OsQueueDbgInit
STATIC INLINE UINT32 OsQueueDbgInitHook(VOID) STATIC INLINE UINT32 OsQueueDbgInitHook(VOID)
{ {
#ifdef LOSCFG_DEBUG_QUEUE #ifdef LOSCFG_DEBUG_QUEUE
@ -52,9 +50,7 @@ STATIC INLINE UINT32 OsQueueDbgInitHook(VOID)
#endif #endif
} }
/* Update the last time the queue was executed */ /* Update the last time the queue was executed */
//更新队列上次执行的时间
extern VOID OsQueueDbgTimeUpdate(UINT32 queueId); extern VOID OsQueueDbgTimeUpdate(UINT32 queueId);
//更新队列执行时间的钩子函数
STATIC INLINE VOID OsQueueDbgTimeUpdateHook(UINT32 queueId) STATIC INLINE VOID OsQueueDbgTimeUpdateHook(UINT32 queueId)
{ {
#ifdef LOSCFG_DEBUG_QUEUE #ifdef LOSCFG_DEBUG_QUEUE
@ -62,9 +58,7 @@ STATIC INLINE VOID OsQueueDbgTimeUpdateHook(UINT32 queueId)
#endif #endif
} }
/* Update the task entry of the queue debug info when created or deleted */ /* Update the task entry of the queue debug info when created or deleted */
//当队列被创建或删除时，更新队列调试信息中的任务入口信息
extern VOID OsQueueDbgUpdate(UINT32 queueId, TSK_ENTRY_FUNC entry); extern VOID OsQueueDbgUpdate(UINT32 queueId, TSK_ENTRY_FUNC entry);
//新队列调试信息的钩子函数
STATIC INLINE VOID OsQueueDbgUpdateHook(UINT32 queueId, TSK_ENTRY_FUNC entry) STATIC INLINE VOID OsQueueDbgUpdateHook(UINT32 queueId, TSK_ENTRY_FUNC entry)
{ {
#ifdef LOSCFG_DEBUG_QUEUE #ifdef LOSCFG_DEBUG_QUEUE
@ -72,9 +66,7 @@ STATIC INLINE VOID OsQueueDbgUpdateHook(UINT32 queueId, TSK_ENTRY_FUNC entry)
#endif #endif
} }
/* check the leak of queue */ /* check the leak of queue */
//检查队列内存泄漏
extern VOID OsQueueCheck(VOID); extern VOID OsQueueCheck(VOID);
//检查队列内存泄漏的钩子函数
STATIC INLINE VOID OsQueueCheckHook(VOID) STATIC INLINE VOID OsQueueCheckHook(VOID)
{ {
#ifdef LOSCFG_DEBUG_QUEUE #ifdef LOSCFG_DEBUG_QUEUE

11
src/kernel/base/include/los_queue_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件定义了私有队列相关的一些结构体、宏和函数声明
#ifndef _LOS_QUEUE_PRI_H #ifndef _LOS_QUEUE_PRI_H
#define _LOS_QUEUE_PRI_H #define _LOS_QUEUE_PRI_H
@ -42,12 +42,12 @@ typedef enum {
OS_QUEUE_WRITE = 1, OS_QUEUE_WRITE = 1,
OS_QUEUE_N_RW = 2 OS_QUEUE_N_RW = 2
} QueueReadWrite; } QueueReadWrite;
//枚举类型，分别表示队列的读写操作和队列头尾操作
typedef enum { typedef enum {
OS_QUEUE_HEAD = 0, OS_QUEUE_HEAD = 0,
OS_QUEUE_TAIL = 1 OS_QUEUE_TAIL = 1
} QueueHeadTail; } QueueHeadTail;
//用于生成或获取队列操作类型和读写类型
#define OS_QUEUE_OPERATE_TYPE(ReadOrWrite, HeadOrTail) (((UINT32)(HeadOrTail) << 1) | (ReadOrWrite)) #define OS_QUEUE_OPERATE_TYPE(ReadOrWrite, HeadOrTail) (((UINT32)(HeadOrTail) << 1) | (ReadOrWrite))
#define OS_QUEUE_READ_WRITE_GET(type) ((type) & 0x01U) #define OS_QUEUE_READ_WRITE_GET(type) ((type) & 0x01U)
#define OS_QUEUE_READ_HEAD (OS_QUEUE_READ | (OS_QUEUE_HEAD << 1)) #define OS_QUEUE_READ_HEAD (OS_QUEUE_READ | (OS_QUEUE_HEAD << 1))
@ -73,7 +73,6 @@ typedef enum {
#define GET_QUEUE_LIST(ptr) LOS_DL_LIST_ENTRY(ptr, LosQueueCB, readWriteList[OS_QUEUE_WRITE]) #define GET_QUEUE_LIST(ptr) LOS_DL_LIST_ENTRY(ptr, LosQueueCB, readWriteList[OS_QUEUE_WRITE])
/* Queue information block structure */ /* Queue information block structure */
//队列信息块结构体，包含了队列的各种属性和状态信息
typedef struct { typedef struct {
UINT8 *queueHandle; /* Pointer to a queue handle */ UINT8 *queueHandle; /* Pointer to a queue handle */
UINT8 queueState; /* state */ UINT8 queueState; /* state */
@ -89,16 +88,12 @@ typedef struct {
} LosQueueCB; } LosQueueCB;
/* Queue information control block */ /* Queue information control block */
//全局变量，指向所有队列信息块的起始地址
extern LosQueueCB *g_allQueue; extern LosQueueCB *g_allQueue;
/* alloc a stationary memory for a mail according to queueId */ /* alloc a stationary memory for a mail according to queueId */
//用于在指定的内存池中为邮件分配内存
extern VOID *OsQueueMailAlloc(UINT32 queueId, VOID *mailPool, UINT32 timeout); extern VOID *OsQueueMailAlloc(UINT32 queueId, VOID *mailPool, UINT32 timeout);
/* free a stationary memory for a mail according to queueId. */ /* free a stationary memory for a mail according to queueId. */
//释放邮件占用的内存
extern UINT32 OsQueueMailFree(UINT32 queueId, VOID *mailPool, VOID *mailMem); extern UINT32 OsQueueMailFree(UINT32 queueId, VOID *mailPool, VOID *mailMem);
//列初始化函数，用于初始化队列池
extern UINT32 OsQueueInit(VOID); extern UINT32 OsQueueInit(VOID);
#ifdef __cplusplus #ifdef __cplusplus

16
src/kernel/base/include/los_sched_debug_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件定义了调度器相关的一些结构体和函数声明
#ifndef __LOS_SCHED_DEBUG_PRI_H #ifndef __LOS_SCHED_DEBUG_PRI_H
#define __LOS_SCHED_DEBUG_PRI_H #define __LOS_SCHED_DEBUG_PRI_H
@ -34,19 +34,19 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//表示单个CPU的运行时间和上下文切换次数
typedef struct { typedef struct {
UINT64 runtime; UINT64 runtime;
UINT32 contexSwitch; UINT32 contexSwitch;
} SchedPercpu; } SchedPercpu;
//表示整个系统的调度统计信息
typedef struct { typedef struct {
UINT64 startRuntime;//开始运行的时间 UINT64 startRuntime;
UINT64 allRuntime;//所有CPU的总共运行时间 UINT64 allRuntime;
UINT32 allContextSwitch;//上下文切换次数 UINT32 allContextSwitch;
SchedPercpu schedPercpu[LOSCFG_KERNEL_CORE_NUM];//每个CPU的具体情况 SchedPercpu schedPercpu[LOSCFG_KERNEL_CORE_NUM];
} SchedStat; } SchedStat;
//用于统计中断处理的时间和次数
extern VOID OsHwiStatistics(size_t intNum); extern VOID OsHwiStatistics(size_t intNum);
#ifdef __cplusplus #ifdef __cplusplus

16
src/kernel/base/include/los_sched_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件定义了调度器相关的一些结构体和函数声明
#ifndef _LOS_SCHED_PRI_H #ifndef _LOS_SCHED_PRI_H
#define _LOS_SCHED_PRI_H #define _LOS_SCHED_PRI_H
@ -37,22 +37,21 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//表示任务调度标志位，每个位代表一个核心，用于防止在OSStartToRun之前进行内核调度
extern UINT32 g_taskScheduled; extern UINT32 g_taskScheduled;
/* /*
* Schedule flag, one bit represents one core. * Schedule flag, one bit represents one core.
* This flag is used to prevent kernel scheduling before OSStartToRun. * This flag is used to prevent kernel scheduling before OSStartToRun.
*/ */
//设置对应核心的调度标志位
#define OS_SCHEDULER_SET(cpuid) do { \ #define OS_SCHEDULER_SET(cpuid) do { \
g_taskScheduled |= (1U << (cpuid)); \ g_taskScheduled |= (1U << (cpuid)); \
} while (0); } while (0);
//清除对应核心的调度标志位
#define OS_SCHEDULER_CLR(cpuid) do { \ #define OS_SCHEDULER_CLR(cpuid) do { \
g_taskScheduled &= ~(1U << (cpuid)); \ g_taskScheduled &= ~(1U << (cpuid)); \
} while (0); } while (0);
//判断当前核心的调度标志位是否激活
#define OS_SCHEDULER_ACTIVE (g_taskScheduled & (1U << ArchCurrCpuid())) #define OS_SCHEDULER_ACTIVE (g_taskScheduled & (1U << ArchCurrCpuid()))
typedef enum { typedef enum {
@ -61,7 +60,6 @@ typedef enum {
} SchedFlag; } SchedFlag;
/* Check if preemptable with counter flag */ /* Check if preemptable with counter flag */
//用于判断当前任务是否可以被抢占
STATIC INLINE BOOL OsPreemptable(VOID) STATIC INLINE BOOL OsPreemptable(VOID)
{ {
/* /*
@ -78,7 +76,7 @@ STATIC INLINE BOOL OsPreemptable(VOID)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
return preemptable; return preemptable;
} }
//用于判断当前任务是否可以在调度过程中被抢占
STATIC INLINE BOOL OsPreemptableInSched(VOID) STATIC INLINE BOOL OsPreemptableInSched(VOID)
{ {
BOOL preemptable = FALSE; BOOL preemptable = FALSE;
@ -106,7 +104,6 @@ STATIC INLINE BOOL OsPreemptableInSched(VOID)
* Current task needs to already be in the right state or the right * Current task needs to already be in the right state or the right
* queues it needs to be in. * queues it needs to be in.
*/ */
//选择下一个任务并切换到它
extern VOID OsSchedResched(VOID); extern VOID OsSchedResched(VOID);
/* /*
@ -114,14 +111,12 @@ extern VOID OsSchedResched(VOID);
* try to do the schedule. However, the schedule won't be definitely * try to do the schedule. However, the schedule won't be definitely
* taken place while there're no other higher priority tasks or locked. * taken place while there're no other higher priority tasks or locked.
*/ */
//将当前任务放回就绪队列，并尝试进行调度
extern VOID OsSchedPreempt(VOID); extern VOID OsSchedPreempt(VOID);
/* /*
* Just like OsSchedPreempt, except this function will do the OS_INT_ACTIVE * Just like OsSchedPreempt, except this function will do the OS_INT_ACTIVE
* check, in case the schedule taken place in the middle of an interrupt. * check, in case the schedule taken place in the middle of an interrupt.
*/ */
//触发调度，如果在中断中则设置调度标志位
STATIC INLINE VOID LOS_Schedule(VOID) STATIC INLINE VOID LOS_Schedule(VOID)
{ {
if (OS_INT_ACTIVE) { if (OS_INT_ACTIVE) {
@ -143,7 +138,6 @@ STATIC INLINE VOID LOS_Schedule(VOID)
* This API is used to check time slices. If the number of Ticks equals to the time for task switch, * This API is used to check time slices. If the number of Ticks equals to the time for task switch,
* tasks are switched. Otherwise, the Tick counting continues. * tasks are switched. Otherwise, the Tick counting continues.
*/ */
//检查时间片，如果满足任务切换的条件则进行切换
extern VOID OsTimesliceCheck(VOID); extern VOID OsTimesliceCheck(VOID);
#endif #endif

7
src/kernel/base/include/los_sem_debug_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件定义了一些用于调试信号量的接口和函数声明
#ifndef _LOS_SEM_DEBUG_PRI_H #ifndef _LOS_SEM_DEBUG_PRI_H
#define _LOS_SEM_DEBUG_PRI_H #define _LOS_SEM_DEBUG_PRI_H
@ -39,9 +39,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* semaphore debug initialization interface */ /* semaphore debug initialization interface */
//信号量调试初始化接口
extern UINT32 OsSemDbgInit(VOID); extern UINT32 OsSemDbgInit(VOID);
//更新信号量最后一次执行的时间
STATIC INLINE UINT32 OsSemDbgInitHook(VOID) STATIC INLINE UINT32 OsSemDbgInitHook(VOID)
{ {
#ifdef LOSCFG_DEBUG_SEMAPHORE #ifdef LOSCFG_DEBUG_SEMAPHORE
@ -51,7 +49,6 @@ STATIC INLINE UINT32 OsSemDbgInitHook(VOID)
#endif #endif
} }
/* Update the last time the semaphore was executed */ /* Update the last time the semaphore was executed */
//更新信号量最后一次执行的时间
extern VOID OsSemDbgTimeUpdate(UINT32 semId); extern VOID OsSemDbgTimeUpdate(UINT32 semId);
STATIC INLINE VOID OsSemDbgTimeUpdateHook(UINT32 semId) STATIC INLINE VOID OsSemDbgTimeUpdateHook(UINT32 semId)
{ {
@ -61,7 +58,6 @@ STATIC INLINE VOID OsSemDbgTimeUpdateHook(UINT32 semId)
return; return;
} }
/* Update the SEM_DEBUG_CB of the semaphore when created or deleted */ /* Update the SEM_DEBUG_CB of the semaphore when created or deleted */
//在创建或删除信号量时更新SEM_DEBUG_CB的信息
extern VOID OsSemDbgUpdate(UINT32 semID, TSK_ENTRY_FUNC creator, UINT16 count); extern VOID OsSemDbgUpdate(UINT32 semID, TSK_ENTRY_FUNC creator, UINT16 count);
STATIC INLINE VOID OsSemDbgUpdateHook(UINT32 semId, TSK_ENTRY_FUNC creator, UINT16 count) STATIC INLINE VOID OsSemDbgUpdateHook(UINT32 semId, TSK_ENTRY_FUNC creator, UINT16 count)
{ {
@ -71,7 +67,6 @@ STATIC INLINE VOID OsSemDbgUpdateHook(UINT32 semId, TSK_ENTRY_FUNC creator, UINT
return; return;
} }
/* get the full data of SEM_DFX_CB */ /* get the full data of SEM_DFX_CB */
//取SEM_DFX_CB的完整数据
extern UINT32 OsSemInfoGetFullData(VOID); extern UINT32 OsSemInfoGetFullData(VOID);
STATIC INLINE VOID OsSemInfoGetFullDataHook(VOID) STATIC INLINE VOID OsSemInfoGetFullDataHook(VOID)
{ {

15
src/kernel/base/include/los_sem_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件定义了一些关于信号量的数据结构和函数声明，用于信号量的控制和管理。
#ifndef _LOS_SEM_PRI_H #ifndef _LOS_SEM_PRI_H
#define _LOS_SEM_PRI_H #define _LOS_SEM_PRI_H
@ -38,28 +38,24 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* Semaphore control structure. */ /* Semaphore control structure. */
//信号量控制块的数据结构
typedef struct { typedef struct {
UINT8 semStat;//信号量的状态 /* Semaphore state, enum LosSemState */ UINT8 semStat; /* Semaphore state, enum LosSemState */
UINT8 semType;//信号量的类型 /* Semaphore Type, enum LosSemType */ UINT8 semType; /* Semaphore Type, enum LosSemType */
UINT16 semCount;//信号量可用数量 /* number of available semaphores */ UINT16 semCount; /* number of available semaphores */
UINT32 semId;//信号量ID /* Semaphore control structure ID, COUNT(UINT16)|INDEX(UINT16) */ UINT32 semId; /* Semaphore control structure ID, COUNT(UINT16)|INDEX(UINT16) */
LOS_DL_LIST semList; /* List of tasks that are waiting on a semaphore */ LOS_DL_LIST semList; /* List of tasks that are waiting on a semaphore */
} LosSemCB; } LosSemCB;
/* Semaphore type */ /* Semaphore type */
//信号量类型的枚举值：包括计数信号量和二进制信号量
enum { enum {
OS_SEM_COUNTING, /* The semaphore is a counting semaphore which max count is LOS_SEM_COUNT_MAX */ OS_SEM_COUNTING, /* The semaphore is a counting semaphore which max count is LOS_SEM_COUNT_MAX */
OS_SEM_BINARY, /* The semaphore is a binary semaphore which max count is OS_SEM_BINARY_COUNT_MAX */ OS_SEM_BINARY, /* The semaphore is a binary semaphore which max count is OS_SEM_BINARY_COUNT_MAX */
}; };
/* Max count of binary semaphores */ /* Max count of binary semaphores */
//二进制信号量的最大计数值
#define OS_SEM_BINARY_COUNT_MAX 1 #define OS_SEM_BINARY_COUNT_MAX 1
/* Semaphore information control block */ /* Semaphore information control block */
//信号量信息控制块的全局指针
extern LosSemCB *g_allSem; extern LosSemCB *g_allSem;
#define GET_SEM_LIST(ptr) LOS_DL_LIST_ENTRY(ptr, LosSemCB, semList) #define GET_SEM_LIST(ptr) LOS_DL_LIST_ENTRY(ptr, LosSemCB, semList)
@ -79,7 +75,6 @@ extern LosSemCB *g_allSem;
/* This API is used to create a semaphore control structure according to the initial number of available semaphores /* This API is used to create a semaphore control structure according to the initial number of available semaphores
* specified by count and return the ID of this semaphore control structure. */ * specified by count and return the ID of this semaphore control structure. */
用于根据初始可用信号量的数量创建信号量控制结构的函数
extern UINT32 OsSemInit(VOID); extern UINT32 OsSemInit(VOID);
#ifdef __cplusplus #ifdef __cplusplus

18
src/kernel/base/include/los_slab_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件是操作系统中关于 Slab 内存分配的底层实现和接口声明
/** /**
* @defgroup los_slab Slab * @defgroup los_slab Slab
* @ingroup kernel * @ingroup kernel
@ -53,7 +53,7 @@ extern "C" {
/* max slab block size */ /* max slab block size */
#define SLAB_MEM_MAX_SIZE (SLAB_MEM_CALSS_STEP_SIZE << (SLAB_MEM_COUNT - 1)) #define SLAB_MEM_MAX_SIZE (SLAB_MEM_CALSS_STEP_SIZE << (SLAB_MEM_COUNT - 1))
//描述 Slab 内存分配器状态的结构体
typedef struct tagLosSlabStatus { typedef struct tagLosSlabStatus {
UINT32 totalSize; UINT32 totalSize;
UINT32 usedSize; UINT32 usedSize;
@ -61,13 +61,13 @@ typedef struct tagLosSlabStatus {
UINT32 allocCount; UINT32 allocCount;
UINT32 freeCount; UINT32 freeCount;
} LosSlabStatus; } LosSlabStatus;
//Slab 块的节点结构体
typedef struct tagOsSlabBlockNode { typedef struct tagOsSlabBlockNode {
UINT16 magic; UINT16 magic;
UINT8 blkSz; UINT8 blkSz;
UINT8 recordId; UINT8 recordId;
} OsSlabBlockNode; } OsSlabBlockNode;
//原子位图结构体，用于表示 Slab 内存分配器中的位图
struct AtomicBitset { struct AtomicBitset {
UINT32 numBits; UINT32 numBits;
UINT32 words[0]; UINT32 words[0];
@ -144,25 +144,25 @@ extern UINT32 OsSlabGetMaxFreeBlkSize(const VOID *pool);
extern VOID *OsSlabCtrlHdrGet(const VOID *pool); extern VOID *OsSlabCtrlHdrGet(const VOID *pool);
#else /* !LOSCFG_KERNEL_MEM_SLAB_EXTENTION */ #else /* !LOSCFG_KERNEL_MEM_SLAB_EXTENTION */
//初始化 Slab 内存池
STATIC INLINE VOID OsSlabMemInit(VOID *pool, UINT32 size) STATIC INLINE VOID OsSlabMemInit(VOID *pool, UINT32 size)
{ {
} }
//销毁 Slab 内存池
STATIC INLINE VOID OsSlabMemDeinit(VOID *pool) STATIC INLINE VOID OsSlabMemDeinit(VOID *pool)
{ {
} }
//从 Slab 内存池中分配内存
STATIC INLINE VOID *OsSlabMemAlloc(VOID *pool, UINT32 size) STATIC INLINE VOID *OsSlabMemAlloc(VOID *pool, UINT32 size)
{ {
return NULL; return NULL;
} }
//释放 Slab 内存池中的内存
STATIC INLINE BOOL OsSlabMemFree(VOID *pool, VOID *ptr) STATIC INLINE BOOL OsSlabMemFree(VOID *pool, VOID *ptr)
{ {
return FALSE; return FALSE;
} }
//检查指针是否属于 Slab 内存池
STATIC INLINE UINT32 OsSlabMemCheck(const VOID *pool, const VOID *ptr) STATIC INLINE UINT32 OsSlabMemCheck(const VOID *pool, const VOID *ptr)
{ {
return (UINT32)-1; return (UINT32)-1;

10
src/kernel/base/include/los_sortlink_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//一个用于操作排序链表（SortLink）的私有头文件。
#ifndef _LOS_SORTLINK_PRI_H #ifndef _LOS_SORTLINK_PRI_H
#define _LOS_SORTLINK_PRI_H #define _LOS_SORTLINK_PRI_H
@ -118,17 +118,13 @@ typedef struct {
UINT16 cursor; UINT16 cursor;
UINT16 reserved; UINT16 reserved;
} SortLinkAttribute; } SortLinkAttribute;
//初始化排序链表
extern UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader); extern UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader);
//一个节点添加到排序链表中
extern VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList); extern VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList);
//从排序链表中删除一个节点
extern VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList); extern VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList);
//获取下一个到期时间
extern UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader); extern UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader);
//获取目标节点的到期时间
extern UINT32 OsSortLinkGetTargetExpireTime(const SortLinkAttribute *sortLinkHeader, extern UINT32 OsSortLinkGetTargetExpireTime(const SortLinkAttribute *sortLinkHeader,
//更新到期时间 const SortLinkList *targetSortList); const SortLinkList *targetSortList);
extern VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttribute *sortLinkHeader); extern VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttribute *sortLinkHeader);
#ifdef __cplusplus #ifdef __cplusplus

19
src/kernel/base/include/los_stackinfo_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//一个用于处理堆栈信息的私有头文件
#ifndef _LOS_STACK_INFO_PRI_H #ifndef _LOS_STACK_INFO_PRI_H
#define _LOS_STACK_INFO_PRI_H #define _LOS_STACK_INFO_PRI_H
@ -37,25 +37,20 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//堆栈信息结构体
typedef struct { typedef struct {
VOID *stackTop;//堆栈的顶部 VOID *stackTop;
UINT32 stackSize;//堆栈的大小 UINT32 stackSize;
CHAR *stackName;//堆栈的名称 CHAR *stackName;
} StackInfo; } StackInfo;
//表示无效的水位线值
#define OS_INVALID_WATERLINE 0xFFFFFFFF #define OS_INVALID_WATERLINE 0xFFFFFFFF
//于检查堆栈顶部的魔术字是否有效的宏定义
#define OS_STACK_MAGIC_CHECK(topstack) (*(UINTPTR *)(topstack) == OS_STACK_MAGIC_WORD) /* 1:magic valid 0:unvalid */ #define OS_STACK_MAGIC_CHECK(topstack) (*(UINTPTR *)(topstack) == OS_STACK_MAGIC_WORD) /* 1:magic valid 0:unvalid */
//用于异常时获取堆栈信息的函数
extern VOID OsExcStackInfo(VOID); extern VOID OsExcStackInfo(VOID);
//用于注册异常时获取的堆栈信息的函数
extern VOID OsExcStackInfoReg(const StackInfo *stackInfo, UINT32 stackNum); extern VOID OsExcStackInfoReg(const StackInfo *stackInfo, UINT32 stackNum);
//用于初始化堆栈的函数
extern VOID OsStackInit(VOID *stacktop, UINT32 stacksize); extern VOID OsStackInit(VOID *stacktop, UINT32 stacksize);
//用于获取堆栈的水位线和使用峰值的函数
extern UINT32 OsStackWaterLineGet(const UINTPTR *stackBottom, const UINTPTR *stackTop, UINT32 *peakUsed); extern UINT32 OsStackWaterLineGet(const UINTPTR *stackBottom, const UINTPTR *stackTop, UINT32 *peakUsed);
//用于获取堆栈信息的函数
extern VOID OsGetStackInfo(const StackInfo **stackInfo, UINT32 *stackNum); extern VOID OsGetStackInfo(const StackInfo **stackInfo, UINT32 *stackNum);
#ifdef __cplusplus #ifdef __cplusplus

17
src/kernel/base/include/los_swtmr_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//一个用于实现软件定时器的私有头文件。
#ifndef _LOS_SWTMR_PRI_H #ifndef _LOS_SWTMR_PRI_H
#define _LOS_SWTMR_PRI_H #define _LOS_SWTMR_PRI_H
@ -40,7 +40,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_BASE_CORE_SWTMR #ifdef LOSCFG_BASE_CORE_SWTMR
//软件定时器的状态枚举，包括未使用、已创建和计时中
enum SwtmrState { enum SwtmrState {
OS_SWTMR_STATUS_UNUSED, /* The software timer is not used. */ OS_SWTMR_STATUS_UNUSED, /* The software timer is not used. */
OS_SWTMR_STATUS_CREATED, /* The software timer is created. */ OS_SWTMR_STATUS_CREATED, /* The software timer is created. */
@ -48,13 +48,12 @@ enum SwtmrState {
}; };
/* Structure of the callback function that handles software timer timeout */ /* Structure of the callback function that handles software timer timeout */
//处理软件定时器超时回调的回调函数结构体
typedef struct { typedef struct {
SWTMR_PROC_FUNC handler; /* Callback function that handles software timer timeout */ SWTMR_PROC_FUNC handler; /* Callback function that handles software timer timeout */
UINTPTR arg; /* Parameter passed in when the callback function UINTPTR arg; /* Parameter passed in when the callback function
that handles software timer timeout is called */ that handles software timer timeout is called */
} SwtmrHandlerItem; } SwtmrHandlerItem;
//软件定时器控制块结构体
typedef struct { typedef struct {
SortLinkList sortList; SortLinkList sortList;
UINT8 state; /* Software timer state */ UINT8 state; /* Software timer state */
@ -72,28 +71,22 @@ typedef struct {
} LosSwtmrCB; } LosSwtmrCB;
/* Type of the pointer to the structure of the callback function that handles software timer timeout */ /* Type of the pointer to the structure of the callback function that handles software timer timeout */
//指向处理软件定时器超时回调的回调函数结构体的指针类型
typedef SwtmrHandlerItem *SwtmrHandlerItemPtr; typedef SwtmrHandlerItem *SwtmrHandlerItemPtr;
//软件定时器控制块数组
extern LosSwtmrCB *g_swtmrCBArray; extern LosSwtmrCB *g_swtmrCBArray;
/* The software timer count list */ /* The software timer count list */
//软件定时器排序链表
extern SortLinkAttribute g_swtmrSortLink; extern SortLinkAttribute g_swtmrSortLink;
#define OS_SWT_FROM_SWTID(swtmrId) ((LosSwtmrCB *)g_swtmrCBArray + ((swtmrId) % KERNEL_SWTMR_LIMIT)) #define OS_SWT_FROM_SWTID(swtmrId) ((LosSwtmrCB *)g_swtmrCBArray + ((swtmrId) % KERNEL_SWTMR_LIMIT))
/* This API is used to scan a software timer when a Tick interrupt occurs and determine whether /* This API is used to scan a software timer when a Tick interrupt occurs and determine whether
* the software timer expires. */ * the software timer expires. */
//在Tick中断发生时扫描软件定时器，判断是否到达超时时间
extern VOID OsSwtmrScan(VOID); extern VOID OsSwtmrScan(VOID);
//初始化软件定时器
extern UINT32 OsSwtmrInit(VOID); extern UINT32 OsSwtmrInit(VOID);
//软件定时器任务，用于处理软件定时器的超时事件
extern VOID OsSwtmrTask(VOID); extern VOID OsSwtmrTask(VOID);
//软件定时器自旋锁
extern SPIN_LOCK_S g_swtmrSpin; extern SPIN_LOCK_S g_swtmrSpin;
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
//判断当前任务是否为软件定时器任务
extern BOOL IsSwtmrTask(UINT32 taskId); extern BOOL IsSwtmrTask(UINT32 taskId);
#endif #endif
#endif /* LOSCFG_BASE_CORE_SWTMR */ #endif /* LOSCFG_BASE_CORE_SWTMR */

3
src/kernel/base/include/los_task_pri.h
Unescape View File

@ -25,8 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这是关于LiteOS中任务调度相关的头文件，其中定义了任务控制块的数据结构和一些任务管理的接口函数。
在这个头文件中，定义了任务的状态、优先级、标志位等信息，并提供了一些操作这些信息的宏和函数。*/
#ifndef _LOS_TASK_PRI_H #ifndef _LOS_TASK_PRI_H
#define _LOS_TASK_PRI_H #define _LOS_TASK_PRI_H

13
src/kernel/base/include/los_tick_pri.h
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//这个头文件是关于系统时钟中断tick的定义和操作。
#ifndef _LOS_TICK_PRI_H #ifndef _LOS_TICK_PRI_H
#define _LOS_TICK_PRI_H #define _LOS_TICK_PRI_H
@ -40,41 +40,30 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* spinlock for tick */ /* spinlock for tick */
//用于保护tick相关操作的自旋锁
extern SPIN_LOCK_S g_tickSpin; extern SPIN_LOCK_S g_tickSpin;
//获取tick自旋锁并保存状态
#define TICK_LOCK(state) LOS_SpinLockSave(&g_tickSpin, &(state)) #define TICK_LOCK(state) LOS_SpinLockSave(&g_tickSpin, &(state))
//释放tick自旋锁并恢复状态
#define TICK_UNLOCK(state) LOS_SpinUnlockRestore(&g_tickSpin, (state)) #define TICK_UNLOCK(state) LOS_SpinUnlockRestore(&g_tickSpin, (state))
/* Count of Ticks */ /* Count of Ticks */
//全局变量，保存系统tick的计数值
extern volatile UINT64 g_tickCount[]; extern volatile UINT64 g_tickCount[];
/* Cycle to nanosecond scale */ /* Cycle to nanosecond scale */
//循环周期到纳秒的转换比例
extern DOUBLE g_cycle2NsScale; extern DOUBLE g_cycle2NsScale;
/* This API is called when the system tick timeout and triggers the interrupt. */ /* This API is called when the system tick timeout and triggers the interrupt. */
//系统tick中断处理函数，当系统tick超时触发中断时调用
extern VOID OsTickHandler(VOID); extern VOID OsTickHandler(VOID);
//初始化系统tick相关配置
extern UINT32 OsTickInit(UINT32 systemClock, UINT32 tickPerSecond); extern UINT32 OsTickInit(UINT32 systemClock, UINT32 tickPerSecond);
//启动系统tick中断
extern VOID OsTickStart(VOID); extern VOID OsTickStart(VOID);
/* Convert from the cycle count to nanosecond. */ /* Convert from the cycle count to nanosecond. */
//将循环周期转换为纳秒
#define CYCLE_TO_NS(cycles) ((cycles) * g_cycle2NsScale) #define CYCLE_TO_NS(cycles) ((cycles) * g_cycle2NsScale)
/** /**
* Current system timer register is 32 bit, therefore TIMER_MAXLOAD define just in order to avoid ambiguity. * Current system timer register is 32 bit, therefore TIMER_MAXLOAD define just in order to avoid ambiguity.
*/ */
//定时器最大加载值，用于避免歧义
#define TIMER_MAXLOAD 0xffffffff #define TIMER_MAXLOAD 0xffffffff
#ifdef LOSCFG_KERNEL_TICKLESS #ifdef LOSCFG_KERNEL_TICKLESS
//tick中断标志，在LOSCFG_KERNEL_TICKLESS选项开启时使用
#define LOS_TICK_INT_FLAG 0x80000000 #define LOS_TICK_INT_FLAG 0x80000000
#endif #endif

12
src/kernel/base/los_bitmap.c
Unescape View File

@ -26,10 +26,6 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这是一个位图（bitmap）的实现，用于对位图进行设置、清除和获取最高/最低位的操作。
该位图使用一个32位无符号整数（UINT32）来表示，每一位都代表一个标记
函数通过位运算来实现对位图的操作，其中包括左移、按位与、按位或、按位取反等操作。*/
#include "los_bitmap.h" #include "los_bitmap.h"
#include "los_toolchain.h" #include "los_toolchain.h"
@ -40,7 +36,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#define OS_BITMAP_MASK 0x1FU #define OS_BITMAP_MASK 0x1FU
//LOS_BitmapSet：将指定位置的位设置为1
VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos) VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos)
{ {
if (bitmap == NULL) { if (bitmap == NULL) {
@ -49,7 +45,7 @@ VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos)
*bitmap |= 1U << (pos & OS_BITMAP_MASK); *bitmap |= 1U << (pos & OS_BITMAP_MASK);
} }
//LOS_BitmapClr：将指定位置的位清除为0
VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos) VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos)
{ {
if (bitmap == NULL) { if (bitmap == NULL) {
@ -58,7 +54,7 @@ VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos)
*bitmap &= ~(1U << (pos & OS_BITMAP_MASK)); *bitmap &= ~(1U << (pos & OS_BITMAP_MASK));
} }
//LOS_HighBitGet：获取位图中最高位（值为1的位置）的索引
UINT16 LOS_HighBitGet(UINT32 bitmap) UINT16 LOS_HighBitGet(UINT32 bitmap)
{ {
if (bitmap == 0) { if (bitmap == 0) {
@ -67,7 +63,7 @@ UINT16 LOS_HighBitGet(UINT32 bitmap)
return (OS_BITMAP_MASK - CLZ(bitmap)); return (OS_BITMAP_MASK - CLZ(bitmap));
} }
//LOS_LowBitGet：获取位图中最低位（值为1的位置）的索引
UINT16 LOS_LowBitGet(UINT32 bitmap) UINT16 LOS_LowBitGet(UINT32 bitmap)
{ {
if (bitmap == 0) { if (bitmap == 0) {

8
src/kernel/base/los_err.c
Unescape View File

@ -25,8 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这段代码是关于错误处理的相关功能，包括注册错误处理函数和执行错误处理的函数。
通过以下接口，用户可以自定义错误处理函数，并在发生错误时进行相应的处理操作。这样可以增强系统的健壮性和容错性，更好地应对各种错误情况。*/
#include "los_err.h" #include "los_err.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -36,9 +35,8 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* Hook function for error handling. */ /* Hook function for error handling. */
//g_usrErrFunc：全局变量，用于保存用户注册的错误处理函数
LITE_OS_SEC_BSS LOS_ERRORHANDLE_FUNC g_usrErrFunc; LITE_OS_SEC_BSS LOS_ERRORHANDLE_FUNC g_usrErrFunc;
//LOS_ErrHandle：用于执行错误处理的函数，当系统出现错误时会调用该函数来处理错误信息
LITE_OS_SEC_TEXT_INIT UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo, UINT32 errorNo, LITE_OS_SEC_TEXT_INIT UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo, UINT32 errorNo,
UINT32 paraLen, VOID *para) UINT32 paraLen, VOID *para)
{ {
@ -48,7 +46,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo, UINT32
return LOS_OK; return LOS_OK;
} }
//LOS_RegErrHandle：用于注册错误处理函数的接口，用户可以通过该函数注册自定义的错误处理函数
LITE_OS_SEC_TEXT_INIT VOID LOS_RegErrHandle(LOS_ERRORHANDLE_FUNC func) LITE_OS_SEC_TEXT_INIT VOID LOS_RegErrHandle(LOS_ERRORHANDLE_FUNC func)
{ {
g_usrErrFunc = func; g_usrErrFunc = func;

34
src/kernel/base/los_event.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这段代码是关于事件管理的实现，包括事件的初始化、读取、写入、清除等操作。*/
#include "los_event_pri.h" #include "los_event_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
#include "los_spinlock.h" #include "los_spinlock.h"
@ -38,7 +38,7 @@
extern "C" { extern "C" {
#endif #endif
#endif /* __cplusplus */ #endif /* __cplusplus */
//LOS_EventInit()函数用于初始化事件控制块（eventCB），并将事件ID、事件列表等属性设置为初始值
LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB) LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB)
{ {
UINT32 intSave; UINT32 intSave;
@ -55,7 +55,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
return LOS_OK; return LOS_OK;
} }
//OsEventParamCheck()函数用于检查参数的有效性，包括事件掩码（eventMask）、模式（mode）等
LITE_OS_SEC_TEXT STATIC UINT32 OsEventParamCheck(const VOID *ptr, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT STATIC UINT32 OsEventParamCheck(const VOID *ptr, UINT32 eventMask, UINT32 mode)
{ {
if (ptr == NULL) { if (ptr == NULL) {
@ -75,17 +75,16 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventParamCheck(const VOID *ptr, UINT32 eventMa
!(mode & (LOS_WAITMODE_OR | LOS_WAITMODE_AND))) { !(mode & (LOS_WAITMODE_OR | LOS_WAITMODE_AND))) {
return LOS_ERRNO_EVENT_FLAGS_INVALID; return LOS_ERRNO_EVENT_FLAGS_INVALID;
} }
//指针非空，事件掩码非0，事件掩码不包含LOS_ERRTYPE_ERROR标志位，模式合法
return LOS_OK; return LOS_OK;
} }
//OsEventPoll()函数用于轮询事件，根据指定的事件掩码和模式判断是否满足条件
LITE_OS_SEC_TEXT STATIC UINT32 OsEventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT STATIC UINT32 OsEventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode)
{ {
UINT32 ret = 0; UINT32 ret = 0;
LOS_ASSERT(ArchIntLocked()); LOS_ASSERT(ArchIntLocked());
LOS_ASSERT(LOS_SpinHeld(&g_taskSpin)); LOS_ASSERT(LOS_SpinHeld(&g_taskSpin));
if (mode & LOS_WAITMODE_OR) { if (mode & LOS_WAITMODE_OR) {
if ((*eventId & eventMask) != 0) { if ((*eventId & eventMask) != 0) {
ret = *eventId & eventMask; ret = *eventId & eventMask;
@ -102,7 +101,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventPoll(UINT32 *eventId, UINT32 eventMask, UI
return ret; return ret;
} }
//OsEventReadCheck()函数用于检查事件读取操作的参数有效性，包括事件控制块（eventCB）、事件掩码（eventMask）、模式（mode）等
LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadCheck(const PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadCheck(const PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode)
{ {
UINT32 ret; UINT32 ret;
@ -123,7 +122,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadCheck(const PEVENT_CB_S eventCB, UINT3
} }
return LOS_OK; return LOS_OK;
} }
//OsEventReadImp()函数是事件读取的实现，根据指定的事件掩码和模式进行轮询，并根据超时时间和是否只读取一次进行相应的操作
LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode,
UINT32 timeout, BOOL once, UINT32 *intSave) UINT32 timeout, BOOL once, UINT32 *intSave)
{ {
@ -166,7 +165,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventM
} }
return ret; return ret;
} }
//OsEventRead()函数是对外提供的事件读取接口，调用OsEventReadCheck()和OsEventReadImp()实现事件的读取操作
LITE_OS_SEC_TEXT STATIC UINT32 OsEventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, LITE_OS_SEC_TEXT STATIC UINT32 OsEventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode,
UINT32 timeout, BOOL once) UINT32 timeout, BOOL once)
{ {
@ -185,7 +184,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventRead(PEVENT_CB_S eventCB, UINT32 eventMask
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return ret; return ret;
} }
//OsEventWrite()函数用于向事件控制块中写入指定的事件
LITE_OS_SEC_TEXT STATIC UINT32 OsEventWrite(PEVENT_CB_S eventCB, UINT32 events, BOOL once) LITE_OS_SEC_TEXT STATIC UINT32 OsEventWrite(PEVENT_CB_S eventCB, UINT32 events, BOOL once)
{ {
LosTaskCB *resumedTask = NULL; LosTaskCB *resumedTask = NULL;
@ -231,7 +230,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventWrite(PEVENT_CB_S eventCB, UINT32 events,
} }
return LOS_OK; return LOS_OK;
} }
//LOS_EventPoll()函数是对外提供的事件轮询接口，调用OsEventParamCheck()和OsEventPoll()实现事件的轮询操作
LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode)
{ {
UINT32 ret; UINT32 ret;
@ -247,17 +246,17 @@ LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return ret; return ret;
} }
//LOS_EventRead()函数是对外提供的事件读取接口，调用OsEventRead()实现事件的读取操作
LITE_OS_SEC_TEXT UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout) LITE_OS_SEC_TEXT UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout)
{ {
return OsEventRead(eventCB, eventMask, mode, timeout, FALSE); return OsEventRead(eventCB, eventMask, mode, timeout, FALSE);
} }
//LOS_EventWrite()函数是对外提供的事件写入接口，调用OsEventWrite()实现事件的写入操作
LITE_OS_SEC_TEXT UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events) LITE_OS_SEC_TEXT UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events)
{ {
return OsEventWrite(eventCB, events, FALSE); return OsEventWrite(eventCB, events, FALSE);
} }
//LOS_EventDestroy()函数用于销毁事件控制块，将事件ID设置为0
LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB) LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB)
{ {
UINT32 intSave; UINT32 intSave;
@ -280,7 +279,7 @@ OUT:
LOS_TRACE(EVENT_DELETE, (UINTPTR)eventCB, ret); LOS_TRACE(EVENT_DELETE, (UINTPTR)eventCB, ret);
return ret; return ret;
} }
//LOS_EventClear()函数用于清除指定的事件
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events)
{ {
UINT32 intSave; UINT32 intSave;
@ -297,19 +296,18 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events)
return LOS_OK; return LOS_OK;
} }
//OsEventWriteOnce()函数是事件写入的实现，与OsEventWrite()类似，但只写入一次
LITE_OS_SEC_TEXT_MINOR UINT32 OsEventWriteOnce(PEVENT_CB_S eventCB, UINT32 events) LITE_OS_SEC_TEXT_MINOR UINT32 OsEventWriteOnce(PEVENT_CB_S eventCB, UINT32 events)
{ {
return OsEventWrite(eventCB, events, TRUE); return OsEventWrite(eventCB, events, TRUE);
} }
#ifdef LOSCFG_COMPAT_POSIX #ifdef LOSCFG_COMPAT_POSIX
//OsEventReadOnce()函数是事件读取的实现，与OsEventRead()类似，但只读取一次
LITE_OS_SEC_TEXT_MINOR UINT32 OsEventReadOnce(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout) LITE_OS_SEC_TEXT_MINOR UINT32 OsEventReadOnce(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout)
{ {
return OsEventRead(eventCB, eventMask, mode, timeout, TRUE); return OsEventRead(eventCB, eventMask, mode, timeout, TRUE);
} }
// /OsEventReadWithCond()函数用于根据条件读取事件，只有当条件满足时才进行事件读取操作
LITE_OS_SEC_TEXT UINT32 OsEventReadWithCond(const EventCond *cond, PEVENT_CB_S eventCB, LITE_OS_SEC_TEXT UINT32 OsEventReadWithCond(const EventCond *cond, PEVENT_CB_S eventCB,
UINT32 eventMask, UINT32 mode, UINT32 timeout) UINT32 eventMask, UINT32 mode, UINT32 timeout)
{ {

51
src/kernel/base/los_exc.c
Unescape View File

@ -25,8 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这是关于LiteOS中异常处理的代码，其中包括记录异常信息、异常信息保存和读取等功能。
同时还包括了一些与异常相关的函数，如打印异常信息、任务回溯等*/
#include "los_exc.h" #include "los_exc.h"
#include "los_printf_pri.h" #include "los_printf_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
@ -49,7 +48,7 @@
extern "C" { extern "C" {
#endif #endif
#endif /* __cplusplus */ #endif /* __cplusplus */
//ExcInfoDumpFormat的结构体类型，包含了用于存储异常信息的缓冲区指针、偏移量、长度和存储地址等信息
#ifdef LOSCFG_SHELL_EXCINFO_DUMP #ifdef LOSCFG_SHELL_EXCINFO_DUMP
typedef struct { typedef struct {
CHAR *buf; /* pointer to the buffer for storing the exception information */ CHAR *buf; /* pointer to the buffer for storing the exception information */
@ -57,13 +56,11 @@ typedef struct {
UINT32 len; /* the size of storing the exception information */ UINT32 len; /* the size of storing the exception information */
UINTPTR dumpAddr; /* the address of storing the exception information */ UINTPTR dumpAddr; /* the address of storing the exception information */
} ExcInfoDumpFormat; } ExcInfoDumpFormat;
//全局变量g_excInfoPool，用于存储异常信息的缓冲区和相关的信息
STATIC ExcInfoDumpFormat g_excInfoPool = {0}; STATIC ExcInfoDumpFormat g_excInfoPool = {0};
/* the hook of read-writing exception information */ /* the hook of read-writing exception information */
STATIC __attribute__((section(".data"))) LogReadWriteFunc g_dumpHook = NULL; STATIC __attribute__((section(".data"))) LogReadWriteFunc g_dumpHook = NULL;
//LOS_ExcInfoRegHook：注册异常信息读写钩子函数，用于设置异常信息的存储地址、长度以及缓冲区等信息
//"钩子函数"是指在特定事件发生时会被调用的函数
//通过使用钩子函数，可以在异常发生时灵活地执行特定的操作，例如记录异常信息、进行特定的处理或通知其他模块进行相应的操作
VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 len, CHAR *buf, LogReadWriteFunc hook) VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 len, CHAR *buf, LogReadWriteFunc hook)
{ {
if ((hook == NULL) || (buf == NULL)) { if ((hook == NULL) || (buf == NULL)) {
@ -81,57 +78,57 @@ VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 len, CHAR *buf, LogReadWriteFu
g_excInfoPool.buf = buf; g_excInfoPool.buf = buf;
g_dumpHook = hook; g_dumpHook = hook;
} }
//OsSetExcInfoRW：设置异常信息读写钩子函数
VOID OsSetExcInfoRW(LogReadWriteFunc func) VOID OsSetExcInfoRW(LogReadWriteFunc func)
{ {
g_dumpHook = func; g_dumpHook = func;
} }
//OsGetExcInfoRW：获取异常信息读写钩子函数
LogReadWriteFunc OsGetExcInfoRW(VOID) LogReadWriteFunc OsGetExcInfoRW(VOID)
{ {
return g_dumpHook; return g_dumpHook;
} }
//OsSetExcInfoBuf：设置异常信息的缓冲区
VOID OsSetExcInfoBuf(CHAR *buf) VOID OsSetExcInfoBuf(CHAR *buf)
{ {
g_excInfoPool.buf = buf; g_excInfoPool.buf = buf;
} }
//OsGetExcInfoBuf：获取异常信息的缓冲区
CHAR *OsGetExcInfoBuf(VOID) CHAR *OsGetExcInfoBuf(VOID)
{ {
return g_excInfoPool.buf; return g_excInfoPool.buf;
} }
//OsSetExcInfoOffset：设置异常信息的偏移量
VOID OsSetExcInfoOffset(UINT32 Offset) VOID OsSetExcInfoOffset(UINT32 Offset)
{ {
g_excInfoPool.offset = Offset; g_excInfoPool.offset = Offset;
} }
//OsGetExcInfoOffset：获取异常信息的偏移量
UINT32 OsGetExcInfoOffset(VOID) UINT32 OsGetExcInfoOffset(VOID)
{ {
return g_excInfoPool.offset; return g_excInfoPool.offset;
} }
//OsSetExcInfoDumpAddr：设置异常信息的存储地址
VOID OsSetExcInfoDumpAddr(UINTPTR addr) VOID OsSetExcInfoDumpAddr(UINTPTR addr)
{ {
g_excInfoPool.dumpAddr = addr; g_excInfoPool.dumpAddr = addr;
} }
//OsGetExcInfoDumpAddr：获取异常信息的存储地址
UINTPTR OsGetExcInfoDumpAddr(VOID) UINTPTR OsGetExcInfoDumpAddr(VOID)
{ {
return g_excInfoPool.dumpAddr; return g_excInfoPool.dumpAddr;
} }
//OsSetExcInfoLen：设置异常信息的长度
VOID OsSetExcInfoLen(UINT32 len) VOID OsSetExcInfoLen(UINT32 len)
{ {
g_excInfoPool.len = len; g_excInfoPool.len = len;
} }
//OsGetExcInfoLen：获取异常信息的长度
UINT32 OsGetExcInfoLen(VOID) UINT32 OsGetExcInfoLen(VOID)
{ {
return g_excInfoPool.len; return g_excInfoPool.len;
} }
//WriteExcBufVa：将格式化的字符串写入异常信息缓冲区
VOID WriteExcBufVa(const CHAR *format, va_list arglist) VOID WriteExcBufVa(const CHAR *format, va_list arglist)
{ {
errno_t ret; errno_t ret;
@ -146,7 +143,7 @@ VOID WriteExcBufVa(const CHAR *format, va_list arglist)
g_excInfoPool.offset += ret; g_excInfoPool.offset += ret;
} }
} }
//WriteExcInfoToBuf：将格式化的字符串写入异常信息缓冲区
VOID WriteExcInfoToBuf(const CHAR *format, ...) VOID WriteExcInfoToBuf(const CHAR *format, ...)
{ {
va_list arglist; va_list arglist;
@ -155,7 +152,7 @@ VOID WriteExcInfoToBuf(const CHAR *format, ...)
WriteExcBufVa(format, arglist); WriteExcBufVa(format, arglist);
va_end(arglist); va_end(arglist);
} }
//OsRecordExcInfoTime：记录异常信息的时间
VOID OsRecordExcInfoTime(VOID) VOID OsRecordExcInfoTime(VOID)
{ {
#define NOW_TIME_LENGTH 24 #define NOW_TIME_LENGTH 24
@ -172,7 +169,7 @@ VOID OsRecordExcInfoTime(VOID)
#undef NOW_TIME_LENGTH #undef NOW_TIME_LENGTH
PrintExcInfo("%s \n", nowTime); PrintExcInfo("%s \n", nowTime);
} }
//OsShellCmdReadExcInfo：读取并打印异常信息的Shell命令
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
INT32 OsShellCmdReadExcInfo(INT32 argc, const CHAR **argv) INT32 OsShellCmdReadExcInfo(INT32 argc, const CHAR **argv)
{ {
@ -203,9 +200,6 @@ SHELLCMD_ENTRY(readExcInfo_shellcmd, CMD_TYPE_EX, "excInfo", 0, (CmdCallBackFunc
#endif #endif
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
//OsCheckExcInteractionTask：检查任务是否为异常交互任务
//异常交互任务通常指的是用于处理异常情况的特殊任务或线程
//当系统发生严重的错误或异常时，需要立即采取相应的措施来处理异常情况，这就需要使用异常交互任务来处理
UINT32 OsCheckExcInteractionTask(const TSK_INIT_PARAM_S *initParam) UINT32 OsCheckExcInteractionTask(const TSK_INIT_PARAM_S *initParam)
{ {
if ((initParam->pfnTaskEntry == (TSK_ENTRY_FUNC)ShellTask) || if ((initParam->pfnTaskEntry == (TSK_ENTRY_FUNC)ShellTask) ||
@ -215,7 +209,7 @@ UINT32 OsCheckExcInteractionTask(const TSK_INIT_PARAM_S *initParam)
} }
return LOS_NOK; return LOS_NOK;
} }
//OsKeepExcInteractionTask：保留异常交互任务，删除其他任务
VOID OsKeepExcInteractionTask(VOID) VOID OsKeepExcInteractionTask(VOID)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
@ -249,7 +243,7 @@ VOID OsKeepExcInteractionTask(VOID)
} }
#endif #endif
//LOS_Panic：打印异常信息并停止CPU执行
VOID LOS_Panic(const CHAR *fmt, ...) VOID LOS_Panic(const CHAR *fmt, ...)
{ {
va_list ap; va_list ap;
@ -258,7 +252,7 @@ VOID LOS_Panic(const CHAR *fmt, ...)
va_end(ap); va_end(ap);
ArchHaltCpu(); ArchHaltCpu();
} }
//LOS_BackTrace：打印当前任务的运行信息和回溯堆栈
VOID LOS_BackTrace(VOID) VOID LOS_BackTrace(VOID)
{ {
#ifdef LOSCFG_BACKTRACE #ifdef LOSCFG_BACKTRACE
@ -268,7 +262,7 @@ VOID LOS_BackTrace(VOID)
ArchBackTrace(); ArchBackTrace();
#endif #endif
} }
//LOS_TaskBackTrace：打印指定任务的运行信息和回溯堆栈
VOID LOS_TaskBackTrace(UINT32 taskID) VOID LOS_TaskBackTrace(UINT32 taskID)
{ {
#ifdef LOSCFG_BACKTRACE #ifdef LOSCFG_BACKTRACE
@ -295,7 +289,6 @@ VOID LOS_TaskBackTrace(UINT32 taskID)
#ifdef __GNUC__ #ifdef __GNUC__
/* stack protector */ /* stack protector */
//__stack_chk_fail：用于栈保护机制，当发现栈被破坏时触发异常处理
VOID __stack_chk_fail(VOID) VOID __stack_chk_fail(VOID)
{ {
/* __builtin_return_address is a builtin function, building in gcc */ /* __builtin_return_address is a builtin function, building in gcc */

61
src/kernel/base/los_hwi.c
Unescape View File

@ -25,9 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
关于LiteOS中硬件中断处理的部分，涉及了中断的注册、删除、触发、使能、禁止等操作
*/
#include "los_hwi_pri.h" #include "los_hwi_pri.h"
#include "los_hwi.h" #include "los_hwi.h"
#include "los_memory.h" #include "los_memory.h"
@ -63,7 +61,7 @@ const HwiControllerOps *g_hwiOps = NULL;
typedef VOID (*HWI_PROC_FUNC0)(VOID); typedef VOID (*HWI_PROC_FUNC0)(VOID);
typedef VOID (*HWI_PROC_FUNC2)(INT32, VOID *); typedef VOID (*HWI_PROC_FUNC2)(INT32, VOID *);
//OsIrqNestingActive：用于在处理中断期间激活中断嵌套计数器，避免在处理时钟中断时进行抢占
STATIC INLINE VOID OsIrqNestingActive(UINT32 hwiNum) STATIC INLINE VOID OsIrqNestingActive(UINT32 hwiNum)
{ {
#ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION #ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION
@ -73,7 +71,7 @@ STATIC INLINE VOID OsIrqNestingActive(UINT32 hwiNum)
} }
#endif #endif
} }
//OsIrqNestingInactive：用于在处理中断结束后禁用中断嵌套计数器
STATIC INLINE VOID OsIrqNestingInactive(UINT32 hwiNum) STATIC INLINE VOID OsIrqNestingInactive(UINT32 hwiNum)
{ {
#ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION #ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION
@ -82,17 +80,17 @@ STATIC INLINE VOID OsIrqNestingInactive(UINT32 hwiNum)
} }
#endif #endif
} }
//OsIrqNestingCntGet：获取当前CPU的中断嵌套计数值
size_t OsIrqNestingCntGet(VOID) size_t OsIrqNestingCntGet(VOID)
{ {
return g_intCount[ArchCurrCpuid()]; return g_intCount[ArchCurrCpuid()];
} }
//OsIrqNestingCntSet：设置当前CPU的中断嵌套计数值
VOID OsIrqNestingCntSet(size_t val) VOID OsIrqNestingCntSet(size_t val)
{ {
g_intCount[ArchCurrCpuid()] = val; g_intCount[ArchCurrCpuid()] = val;
} }
//InterruptHandle：处理中断的实际函数，根据中断号调用对应的中断处理函数
STATIC INLINE VOID InterruptHandle(HwiHandleInfo *hwiForm) STATIC INLINE VOID InterruptHandle(HwiHandleInfo *hwiForm)
{ {
hwiForm->respCount++; hwiForm->respCount++;
@ -116,7 +114,7 @@ STATIC INLINE VOID InterruptHandle(HwiHandleInfo *hwiForm)
} }
#endif #endif
} }
//OsIntHandle：中断处理入口函数，负责处理中断前的一些准备工作，如调用中断处理前的钩子函数等
VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *hwiForm) VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *hwiForm)
{ {
size_t *intCnt = NULL; size_t *intCnt = NULL;
@ -150,7 +148,7 @@ VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *hwiForm)
OsCpupIrqEnd(hwiNum); OsCpupIrqEnd(hwiNum);
#endif #endif
} }
//OsIntEntry：中断向量入口函数，根据中断号调用对应的中断处理函数
VOID OsIntEntry(VOID) VOID OsIntEntry(VOID)
{ {
if ((g_hwiOps != NULL) && (g_hwiOps->handleIrq != NULL)) { if ((g_hwiOps != NULL) && (g_hwiOps->handleIrq != NULL)) {
@ -158,7 +156,7 @@ VOID OsIntEntry(VOID)
} }
return; return;
} }
//OsHwiCpIrqParam：根据传入的中断参数结构体分配内存，并将参数信息拷贝到新分配的内存中
STATIC HWI_ARG_T OsHwiCpIrqParam(const HWI_IRQ_PARAM_S *irqParam) STATIC HWI_ARG_T OsHwiCpIrqParam(const HWI_IRQ_PARAM_S *irqParam)
{ {
HWI_IRQ_PARAM_S *paramByAlloc = NULL; HWI_IRQ_PARAM_S *paramByAlloc = NULL;
@ -171,7 +169,6 @@ STATIC HWI_ARG_T OsHwiCpIrqParam(const HWI_IRQ_PARAM_S *irqParam)
return (HWI_ARG_T)paramByAlloc; return (HWI_ARG_T)paramByAlloc;
} }
#ifndef LOSCFG_SHARED_IRQ #ifndef LOSCFG_SHARED_IRQ
//OsHwiDel：删除指定的中断处理函数
STATIC UINT32 OsHwiDel(HwiHandleInfo *hwiForm, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId) STATIC UINT32 OsHwiDel(HwiHandleInfo *hwiForm, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId)
{ {
UINT32 intSave; UINT32 intSave;
@ -193,7 +190,7 @@ STATIC UINT32 OsHwiDel(HwiHandleInfo *hwiForm, const HWI_IRQ_PARAM_S *irqParam,
HWI_UNLOCK(intSave); HWI_UNLOCK(intSave);
return LOS_OK; return LOS_OK;
} }
//OsHwiCreate：创建中断处理函数，并将其添加到中断处理链表中
STATIC UINT32 OsHwiCreate(HwiHandleInfo *hwiForm, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler, STATIC UINT32 OsHwiCreate(HwiHandleInfo *hwiForm, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler,
const HWI_IRQ_PARAM_S *irqParam) const HWI_IRQ_PARAM_S *irqParam)
{ {
@ -221,7 +218,6 @@ STATIC UINT32 OsHwiCreate(HwiHandleInfo *hwiForm, HWI_MODE_T hwiMode, HWI_PROC_F
return LOS_OK; return LOS_OK;
} }
#else /* LOSCFG_SHARED_IRQ */ #else /* LOSCFG_SHARED_IRQ */
//函数OsFreeHwiNode:用于释放中断处理函数节点，并在需要时禁止该中断
STATIC INLINE UINT32 OsFreeHwiNode(HwiHandleInfo *head, HwiHandleInfo *hwiForm, UINT32 irqId) STATIC INLINE UINT32 OsFreeHwiNode(HwiHandleInfo *head, HwiHandleInfo *hwiForm, UINT32 irqId)
{ {
UINT32 ret = LOS_OK; UINT32 ret = LOS_OK;
@ -244,8 +240,7 @@ STATIC INLINE UINT32 OsFreeHwiNode(HwiHandleInfo *head, HwiHandleInfo *hwiForm,
return ret; return ret;
} }
//OsHwiDel:用于删除硬件中断处理函数，它首先判断中断是否是共享中断
//如果不是，则直接释放该中断的处理函数节点;如果是共享中断，则遍历链表找到对应的设备ID，然后释放该中断的处理函数节点
STATIC UINT32 OsHwiDel(HwiHandleInfo *head, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId) STATIC UINT32 OsHwiDel(HwiHandleInfo *head, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId)
{ {
HwiHandleInfo *hwiFormPrev = NULL; HwiHandleInfo *hwiFormPrev = NULL;
@ -295,8 +290,7 @@ STATIC UINT32 OsHwiDel(HwiHandleInfo *head, const HWI_IRQ_PARAM_S *irqParam, UIN
HWI_UNLOCK(intSave); HWI_UNLOCK(intSave);
return ret; return ret;
} }
//OsHwiCreate:用于创建硬件中断处理函数，它首先判断中断是否是共享中断，并检查是否已经存在具有相同设备ID的中断处理函数节点，如果存在则返回错误
//然后申请内存并初始化新的中断处理函数节点，将其添加到链表中
STATIC UINT32 OsHwiCreate(HwiHandleInfo *head, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler, STATIC UINT32 OsHwiCreate(HwiHandleInfo *head, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler,
const HWI_IRQ_PARAM_S *irqParam) const HWI_IRQ_PARAM_S *irqParam)
{ {
@ -365,9 +359,7 @@ size_t IntActive()
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
return intCount; return intCount;
} }
//LOS_HwiCreate 函数：用于创建硬件中断处理函数
//它会注册一个中断处理函数，并将其与指定的硬件中断号相关联
//可以设置中断的优先级、硬件中断模式和处理函数
LITE_OS_SEC_TEXT UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum, LITE_OS_SEC_TEXT UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,
HWI_PRIOR_T hwiPrio, HWI_PRIOR_T hwiPrio,
HWI_MODE_T hwiMode, HWI_MODE_T hwiMode,
@ -404,8 +396,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,
} }
return ret; return ret;
} }
//LOS_HwiDelete 函数：用于删除已经创建的硬件中断处理函数
//通过指定硬件中断号，可以将之前注册的中断处理函数从系统中删除
LITE_OS_SEC_TEXT UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam) LITE_OS_SEC_TEXT UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam)
{ {
UINT32 ret; UINT32 ret;
@ -426,8 +417,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqP
return ret; return ret;
} }
//LOS_HwiTrigger 函数：用于手动触发指定的硬件中断
//调用该函数后，会立即触发对应的硬件中断，使得系统执行相应的中断处理函数
LITE_OS_SEC_TEXT UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->triggerIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->triggerIrq == NULL)) {
@ -437,8 +427,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum)
return g_hwiOps->triggerIrq(hwiNum); return g_hwiOps->triggerIrq(hwiNum);
} }
//LOS_HwiEnable 函数：用于使能指定的硬件中断
//调用该函数后，系统将允许对应的硬件中断产生，并执行相应的中断处理函数
LITE_OS_SEC_TEXT UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->enableIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->enableIrq == NULL)) {
@ -448,8 +437,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum)
return g_hwiOps->enableIrq(hwiNum); return g_hwiOps->enableIrq(hwiNum);
} }
//LOS_HwiDisable 函数：用于禁止指定的硬件中断
//调用该函数后，系统将阻止对应的硬件中断产生，屏蔽其影响
LITE_OS_SEC_TEXT UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->disableIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->disableIrq == NULL)) {
@ -459,8 +447,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum)
return g_hwiOps->disableIrq(hwiNum); return g_hwiOps->disableIrq(hwiNum);
} }
//LOS_HwiClear 函数：用于清除指定的硬件中断
//在某些平台上，硬件中断发生后可能需要手动清除中断标志位，以便正确处理后续的中断
LITE_OS_SEC_TEXT UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->clearIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->clearIrq == NULL)) {
@ -470,8 +457,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum)
return g_hwiOps->clearIrq(hwiNum); return g_hwiOps->clearIrq(hwiNum);
} }
//LOS_HwiSetPriority 函数：用于设置硬件中断的优先级
//通过指定硬件中断号和优先级，可以调整硬件中断的触发顺序
LITE_OS_SEC_TEXT UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority) LITE_OS_SEC_TEXT UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->setIrqPriority == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->setIrqPriority == NULL)) {
@ -482,8 +468,6 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T prio
return g_hwiOps->setIrqPriority(hwiNum, priority); return g_hwiOps->setIrqPriority(hwiNum, priority);
} }
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
//LOS_HwiSetAffinity函数：用于设置硬件中断的处理CPU亲和性
//它首先检查硬件中断操作函数指针是否为空，然后调用具体的操作函数来设置中断的处理CPU亲和性
LITE_OS_SEC_TEXT UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask) LITE_OS_SEC_TEXT UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->setIrqCpuAffinity == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->setIrqCpuAffinity == NULL)) {
@ -493,8 +477,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
return g_hwiOps->setIrqCpuAffinity(hwiNum, cpuMask); return g_hwiOps->setIrqCpuAffinity(hwiNum, cpuMask);
} }
//LOS_HwiSendIpi函数：用于发送硬件中断处理请求给指定的CPU
//它首先检查硬件中断操作函数指针是否为空，然后调用具体的操作函数来发送中断处理请求
LITE_OS_SEC_TEXT UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask) LITE_OS_SEC_TEXT UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->sendIpi == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->sendIpi == NULL)) {
@ -507,8 +490,6 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
#endif #endif
#ifdef LOSCFG_KERNEL_LOWPOWER #ifdef LOSCFG_KERNEL_LOWPOWER
//LOS_IntWakeupHookReg函数：用于注册中断唤醒回调函数
//它将传入的回调函数赋值给全局变量g_intWakeupHook，以便在中断唤醒时调用该回调函数
LITE_OS_SEC_TEXT_MINOR VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook) LITE_OS_SEC_TEXT_MINOR VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook)
{ {
g_intWakeupHook = hook; g_intWakeupHook = hook;
@ -516,8 +497,6 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook)
#endif #endif
/* Initialization of the hardware interrupt */ /* Initialization of the hardware interrupt */
//OsHwiInit函数：用于初始化硬件中断
//它会调用具体的平台相关函数来进行硬件中断的初始化操作
LITE_OS_SEC_TEXT_INIT VOID OsHwiInit(VOID) LITE_OS_SEC_TEXT_INIT VOID OsHwiInit(VOID)
{ {
ArchIrqInit(); ArchIrqInit();

25
src/kernel/base/los_lockdep.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这段代码是关于锁依赖检查的实现。包含了一些头文件和函数的定义，用于在多核系统中检测锁的使用情况*/
#include "los_base.h" #include "los_base.h"
#include "los_spinlock.h" #include "los_spinlock.h"
#include "los_task_pri.h" #include "los_task_pri.h"
@ -47,8 +47,6 @@ extern "C" {
STATIC Atomic g_lockdepAvailable = 1; STATIC Atomic g_lockdepAvailable = 1;
/* atomic insurance for lockdep check */ /* atomic insurance for lockdep check */
//OsLockDepRequire：该函数用于获取锁依赖检查的原子操作，确保在进行锁依赖检查时不会被中断
//原子操作是指在计算机科学中，不会被中断的操作
STATIC INLINE VOID OsLockDepRequire(UINT32 *intSave) STATIC INLINE VOID OsLockDepRequire(UINT32 *intSave)
{ {
*intSave = LOS_IntLock(); *intSave = LOS_IntLock();
@ -56,13 +54,13 @@ STATIC INLINE VOID OsLockDepRequire(UINT32 *intSave)
/* busy waiting */ /* busy waiting */
} }
} }
//OsLockDepRelease：释放锁依赖检查的原子操作，用于在完成锁依赖检查后恢复正常的中断状态
STATIC INLINE VOID OsLockDepRelease(UINT32 intSave) STATIC INLINE VOID OsLockDepRelease(UINT32 intSave)
{ {
LOS_AtomicSet(&g_lockdepAvailable, 1); LOS_AtomicSet(&g_lockdepAvailable, 1);
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
//OsLockDepGetCycles：获取当前 CPU 的周期计数器的值，用于记录锁请求和释放时的时间戳
STATIC INLINE UINT64 OsLockDepGetCycles(VOID) STATIC INLINE UINT64 OsLockDepGetCycles(VOID)
{ {
UINT32 high, low; UINT32 high, low;
@ -71,7 +69,7 @@ STATIC INLINE UINT64 OsLockDepGetCycles(VOID)
/* combine cycleHi and cycleLo into 8 bytes cycles */ /* combine cycleHi and cycleLo into 8 bytes cycles */
return (((UINT64)high << 32) + low); return (((UINT64)high << 32) + low);
} }
//OsLockDepErrorStringGet：根据错误类型返回对应的错误字符串，用于打印错误信息
STATIC INLINE CHAR *OsLockDepErrorStringGet(enum LockDepErrType type) STATIC INLINE CHAR *OsLockDepErrorStringGet(enum LockDepErrType type)
{ {
CHAR *errorString = NULL; CHAR *errorString = NULL;
@ -96,7 +94,7 @@ STATIC INLINE CHAR *OsLockDepErrorStringGet(enum LockDepErrType type)
return errorString; return errorString;
} }
//OsLockDepPanic：当发生严重错误时触发系统的崩溃，通常在检测到死锁等无法修复的情况下调用
WEAK VOID OsLockDepPanic(enum LockDepErrType errType) WEAK VOID OsLockDepPanic(enum LockDepErrType errType)
{ {
/* halt here */ /* halt here */
@ -105,7 +103,7 @@ WEAK VOID OsLockDepPanic(enum LockDepErrType errType)
OsBackTrace(); OsBackTrace();
while (1) {} while (1) {}
} }
//OsLockDepDumpLock：输出锁依赖检查失败时的调试信息，包括任务名、任务 ID、CPU 号等，并最终触发崩溃
STATIC VOID OsLockDepDumpLock(const LosTaskCB *task, const SPIN_LOCK_S *lock, STATIC VOID OsLockDepDumpLock(const LosTaskCB *task, const SPIN_LOCK_S *lock,
const VOID *requestAddr, enum LockDepErrType errType) const VOID *requestAddr, enum LockDepErrType errType)
{ {
@ -145,7 +143,7 @@ STATIC VOID OsLockDepDumpLock(const LosTaskCB *task, const SPIN_LOCK_S *lock,
OsLockDepPanic(errType); OsLockDepPanic(errType);
} }
//OsLockDepCheckDependancy：检查当前任务与锁的所有者之间是否存在依赖关系，以避免死锁
STATIC BOOL OsLockDepCheckDependancy(const LosTaskCB *current, const LosTaskCB *lockOwner) STATIC BOOL OsLockDepCheckDependancy(const LosTaskCB *current, const LosTaskCB *lockOwner)
{ {
BOOL checkResult = TRUE; BOOL checkResult = TRUE;
@ -166,7 +164,7 @@ STATIC BOOL OsLockDepCheckDependancy(const LosTaskCB *current, const LosTaskCB *
return checkResult; return checkResult;
} }
//OsLockDepCheckIn：在请求锁时进行依赖检查，记录锁的请求地址和等待时间，如检查失败则触发崩溃
VOID OsLockDepCheckIn(const SPIN_LOCK_S *lock) VOID OsLockDepCheckIn(const SPIN_LOCK_S *lock)
{ {
UINT32 intSave; UINT32 intSave;
@ -219,7 +217,7 @@ OUT:
OsLockDepRelease(intSave); OsLockDepRelease(intSave);
} }
//OsLockDepRecord：记录成功获取锁的时间戳和持有者信息，并更新锁的所有者和 CPU 号等信息
VOID OsLockDepRecord(SPIN_LOCK_S *lock) VOID OsLockDepRecord(SPIN_LOCK_S *lock)
{ {
UINT32 intSave; UINT32 intSave;
@ -252,7 +250,7 @@ VOID OsLockDepRecord(SPIN_LOCK_S *lock)
OsLockDepRelease(intSave); OsLockDepRelease(intSave);
} }
//OsLockDepCheckOut：在释放锁时进行依赖检查，记录持有时间并清除相关信息，如检查失败则触发崩溃
VOID OsLockDepCheckOut(SPIN_LOCK_S *lock) VOID OsLockDepCheckOut(SPIN_LOCK_S *lock)
{ {
UINT32 intSave; UINT32 intSave;
@ -304,8 +302,7 @@ VOID OsLockDepCheckOut(SPIN_LOCK_S *lock)
OUT: OUT:
OsLockDepRelease(intSave); OsLockDepRelease(intSave);
} }
//OsLockdepClearSpinlocks：清除当前任务持有的所有自旋锁，通常在系统处于异常状态下调用以确保解锁
//自旋锁是一种用于多线程同步的机制。在使用自旋锁时，线程会反复检查锁是否被释放，如果锁已经被占用，线程就会一直循环等待，直到锁被释放为止
VOID OsLockdepClearSpinlocks(VOID) VOID OsLockdepClearSpinlocks(VOID)
{ {
LosTaskCB *task = OsCurrTaskGet(); LosTaskCB *task = OsCurrTaskGet();

42
src/kernel/base/los_misc.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//操作系统的基础函数
#include "los_task_pri.h" #include "los_task_pri.h"
#include "los_misc_pri.h" #include "los_misc_pri.h"
#include "los_memory_pri.h" #include "los_memory_pri.h"
@ -48,23 +48,23 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_LIB_CONFIGURABLE #ifdef LOSCFG_LIB_CONFIGURABLE
LITE_OS_SEC_BSS UINT32 g_osSysClock; //操作系统的系统时钟频率 LITE_OS_SEC_BSS UINT32 g_osSysClock;
LITE_OS_SEC_BSS UINT32 g_semLimit; //信号量的最大数量限制 LITE_OS_SEC_BSS UINT32 g_semLimit;
LITE_OS_SEC_BSS UINT32 g_muxLimit; //互斥锁的最大数量限制 LITE_OS_SEC_BSS UINT32 g_muxLimit;
LITE_OS_SEC_BSS UINT32 g_queueLimit; //队列最大数量限制 LITE_OS_SEC_BSS UINT32 g_queueLimit;
LITE_OS_SEC_BSS UINT32 g_swtmrLimit; //软件定时器的最大数量限制 LITE_OS_SEC_BSS UINT32 g_swtmrLimit;
LITE_OS_SEC_BSS UINT32 g_taskLimit; //任务的最大数量限制 LITE_OS_SEC_BSS UINT32 g_taskLimit;
LITE_OS_SEC_BSS UINT32 g_minusOneTickPerSecond; //每秒减去的滴答数，用于时间戳计算 LITE_OS_SEC_BSS UINT32 g_minusOneTickPerSecond;
LITE_OS_SEC_BSS UINT32 g_taskMinStkSize;//任务的最小堆栈大小 LITE_OS_SEC_BSS UINT32 g_taskMinStkSize;
LITE_OS_SEC_BSS UINT32 g_taskIdleStkSize; //空闲任务的堆栈大小 LITE_OS_SEC_BSS UINT32 g_taskIdleStkSize;
LITE_OS_SEC_BSS UINT32 g_taskSwtmrStkSize; //软件定时器任务的堆栈大小 LITE_OS_SEC_BSS UINT32 g_taskSwtmrStkSize;
LITE_OS_SEC_BSS UINT32 g_taskDfltStkSize; //默认任务的堆栈大小 LITE_OS_SEC_BSS UINT32 g_taskDfltStkSize;
LITE_OS_SEC_BSS UINT32 g_timeSliceTimeOut; //时间片的超时时间 LITE_OS_SEC_BSS UINT32 g_timeSliceTimeOut;
LITE_OS_SEC_DATA BOOL g_nxEnabled = FALSE; //是否启用了内存保护机制 LITE_OS_SEC_DATA BOOL g_nxEnabled = FALSE;
LITE_OS_SEC_BSS UINTPTR g_dlNxHeapBase; //动态加载库的内存堆起始地址 LITE_OS_SEC_BSS UINTPTR g_dlNxHeapBase;
LITE_OS_SEC_BSS UINT32 g_dlNxHeapSize; //动态加载库的内存堆大小 LITE_OS_SEC_BSS UINT32 g_dlNxHeapSize;
#endif #endif
#ifdef LOSCFG_KERNEL_TRACE #ifdef LOSCFG_KERNEL_TRACE
@ -77,12 +77,11 @@ LMS_INIT_HOOK g_lmsMemInitHook = NULL;
LMS_FUNC_HOOK g_lmsMallocHook = NULL; LMS_FUNC_HOOK g_lmsMallocHook = NULL;
LMS_FUNC_HOOK g_lmsFreeHook = NULL; LMS_FUNC_HOOK g_lmsFreeHook = NULL;
#endif #endif
//LOS_Align：用于将给定的地址按指定的边界对齐，返回对齐后的地址
LITE_OS_SEC_TEXT UINTPTR LOS_Align(UINTPTR addr, UINT32 boundary) LITE_OS_SEC_TEXT UINTPTR LOS_Align(UINTPTR addr, UINT32 boundary)
{ {
return (addr + boundary - 1) & ~((UINTPTR)(boundary - 1)); return (addr + boundary - 1) & ~((UINTPTR)(boundary - 1));
} }
//OsDumpMemByte：用于以字节为单位打印内存中的数据
LITE_OS_SEC_TEXT_MINOR VOID LOS_Msleep(UINT32 msecs) LITE_OS_SEC_TEXT_MINOR VOID LOS_Msleep(UINT32 msecs)
{ {
UINT32 interval; UINT32 interval;
@ -98,7 +97,7 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_Msleep(UINT32 msecs)
(VOID)LOS_TaskDelay(interval); (VOID)LOS_TaskDelay(interval);
} }
//OsDumpMemByte：用于以字节为单位打印内存中的数据
VOID OsDumpMemByte(size_t length, UINTPTR addr) VOID OsDumpMemByte(size_t length, UINTPTR addr)
{ {
size_t dataLen; size_t dataLen;
@ -142,7 +141,6 @@ VOID OsDumpMemByte(size_t length, UINTPTR addr)
} }
#if defined(LOSCFG_DEBUG_SEMAPHORE) || defined(LOSCFG_DEBUG_MUTEX) || defined(LOSCFG_DEBUG_QUEUE) #if defined(LOSCFG_DEBUG_SEMAPHORE) || defined(LOSCFG_DEBUG_MUTEX) || defined(LOSCFG_DEBUG_QUEUE)
//OsArraySort：快速排序
VOID OsArraySort(UINT32 *sortArray, UINT32 start, UINT32 end, VOID OsArraySort(UINT32 *sortArray, UINT32 start, UINT32 end,
const SortParam *sortParam, OsCompareFunc compareFunc) const SortParam *sortParam, OsCompareFunc compareFunc)
{ {

20
src/kernel/base/los_mp.c
Unescape View File

@ -25,8 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*针对多处理器（SMP）系统的操作系统内核部分的实现
主要包括了多处理器调度、任务管理和中断处理等功能*/
#include "los_mp_pri.h" #include "los_mp_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
#include "los_percpu_pri.h" #include "los_percpu_pri.h"
@ -46,7 +45,7 @@ LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_mpCallSpin);
#define MP_CALL_LOCK(state) LOS_SpinLockSave(&g_mpCallSpin, &(state)) #define MP_CALL_LOCK(state) LOS_SpinLockSave(&g_mpCallSpin, &(state))
#define MP_CALL_UNLOCK(state) LOS_SpinUnlockRestore(&g_mpCallSpin, (state)) #define MP_CALL_UNLOCK(state) LOS_SpinUnlockRestore(&g_mpCallSpin, (state))
#endif #endif
//LOS_MpSchedule：多处理器调度函数，用于向指定的处理器发送调度中断
VOID LOS_MpSchedule(UINT32 target) VOID LOS_MpSchedule(UINT32 target)
{ {
UINT32 ret; UINT32 ret;
@ -58,12 +57,12 @@ VOID LOS_MpSchedule(UINT32 target)
} }
return; return;
} }
//OsMpWakeHandler：多处理器唤醒处理函数，目前为空实现，无特定操作
VOID OsMpWakeHandler(VOID) VOID OsMpWakeHandler(VOID)
{ {
/* generic wakeup ipi, do nothing */ /* generic wakeup ipi, do nothing */
} }
//OsMpScheduleHandler：多处理器调度处理函数，设置调度标志以触发调度器在中断结束时执行调度
VOID OsMpScheduleHandler(VOID) VOID OsMpScheduleHandler(VOID)
{ {
/* /*
@ -72,7 +71,7 @@ VOID OsMpScheduleHandler(VOID)
*/ */
OsPercpuGet()->schedFlag = INT_PEND_RESCH; OsPercpuGet()->schedFlag = INT_PEND_RESCH;
} }
//OsMpHaltHandler：多处理器停机处理函数，将当前处理器标记为已停机状态，并进入死循环
VOID OsMpHaltHandler(VOID) VOID OsMpHaltHandler(VOID)
{ {
(VOID)LOS_IntLock(); (VOID)LOS_IntLock();
@ -80,7 +79,7 @@ VOID OsMpHaltHandler(VOID)
while (1) {} while (1) {}
} }
//OsMpCollectTasks：多处理器任务回收函数，用于递归检查所有可用任务，并删除标记为需要销毁的任务
VOID OsMpCollectTasks(VOID) VOID OsMpCollectTasks(VOID)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
@ -110,7 +109,6 @@ VOID OsMpCollectTasks(VOID)
} }
#ifdef LOSCFG_KERNEL_SMP_CALL #ifdef LOSCFG_KERNEL_SMP_CALL
//OsMpFuncCall：多处理器函数调用函数，用于向指定的处理器发送函数调用请求
VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args) VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args)
{ {
UINT32 index; UINT32 index;
@ -146,7 +144,7 @@ VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args)
} }
return; return;
} }
//OsMpFuncCallHandler：多处理器函数调用处理函数，从本处理器的函数调用队列中取出并执行函数调用请求
VOID OsMpFuncCallHandler(VOID) VOID OsMpFuncCallHandler(VOID)
{ {
UINT32 intSave; UINT32 intSave;
@ -168,7 +166,7 @@ VOID OsMpFuncCallHandler(VOID)
} }
MP_CALL_UNLOCK(intSave); MP_CALL_UNLOCK(intSave);
} }
//OsMpFuncCallInit：多处理器函数调用初始化函数，用于初始化每个核心的函数调用队列
VOID OsMpFuncCallInit(VOID) VOID OsMpFuncCallInit(VOID)
{ {
UINT32 index; UINT32 index;
@ -178,7 +176,7 @@ VOID OsMpFuncCallInit(VOID)
} }
} }
#endif /* LOSCFG_KERNEL_SMP_CALL */ #endif /* LOSCFG_KERNEL_SMP_CALL */
//OsMpInit：多处理器初始化函数，包括创建周期性软件定时器和初始化函数调用队列等
UINT32 OsMpInit(VOID) UINT32 OsMpInit(VOID)
{ {
UINT16 swtmrId; UINT16 swtmrId;

25
src/kernel/base/los_mux.c
Unescape View File

@ -25,8 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*代码实现了一个简单的互斥锁（Mutex），用于保护共享资源的访问
互斥锁的主要功能是确保在同一时间只有一个线程可以访问被保护的代码块或共享资源，从而避免并发访问引发的数据竞争和不一致性*/
#include "los_mux_pri.h" #include "los_mux_pri.h"
#include "los_mux_debug_pri.h" #include "los_mux_debug_pri.h"
#include "los_bitmap.h" #include "los_bitmap.h"
@ -50,7 +49,6 @@ LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_unusedMuxList;
* Description : Initializes the mutex * Description : Initializes the mutex
* Return : LOS_OK on success, or error code on failure * Return : LOS_OK on success, or error code on failure
*/ */
//OsMuxInit：Mutex初始化函数，用于初始化Mutex数据结构并设置初始状态
LITE_OS_SEC_TEXT UINT32 OsMuxInit(VOID) LITE_OS_SEC_TEXT UINT32 OsMuxInit(VOID)
{ {
LosMuxCB *muxNode = NULL; LosMuxCB *muxNode = NULL;
@ -76,7 +74,7 @@ LITE_OS_SEC_TEXT UINT32 OsMuxInit(VOID)
} }
return LOS_OK; return LOS_OK;
} }
//LOS_MuxCreate：创建Mutex函数，用于创建一个新的Mutex对象，并返回其句柄
LITE_OS_SEC_TEXT UINT32 LOS_MuxCreate(UINT32 *muxHandle) LITE_OS_SEC_TEXT UINT32 LOS_MuxCreate(UINT32 *muxHandle)
{ {
UINT32 intSave; UINT32 intSave;
@ -115,7 +113,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_MuxCreate(UINT32 *muxHandle)
ERR_HANDLER: ERR_HANDLER:
OS_RETURN_ERROR_P2(errLine, errNo); OS_RETURN_ERROR_P2(errLine, errNo);
} }
//LOS_MuxDelete：删除Mutex函数，用于删除指定的Mutex对象及其相关资源
LITE_OS_SEC_TEXT UINT32 LOS_MuxDelete(UINT32 muxHandle) LITE_OS_SEC_TEXT UINT32 LOS_MuxDelete(UINT32 muxHandle)
{ {
UINT32 intSave; UINT32 intSave;
@ -156,7 +154,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_MuxDelete(UINT32 muxHandle)
ERR_HANDLER: ERR_HANDLER:
OS_RETURN_ERROR_P2(errLine, errNo); OS_RETURN_ERROR_P2(errLine, errNo);
} }
//OsMuxParaCheck 函数主要用于验证互斥量操作的参数是否有效，包括互斥量是否被正确创建和传入的句柄是否有效，以及当前是否处于中断上下文
LITE_OS_SEC_TEXT STATIC UINT32 OsMuxParaCheck(const LosMuxCB *muxCB, UINT32 muxHandle) LITE_OS_SEC_TEXT STATIC UINT32 OsMuxParaCheck(const LosMuxCB *muxCB, UINT32 muxHandle)
{ {
if ((muxCB->muxStat == LOS_UNUSED) || (muxCB->muxId != muxHandle)) { if ((muxCB->muxStat == LOS_UNUSED) || (muxCB->muxId != muxHandle)) {
@ -170,7 +168,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsMuxParaCheck(const LosMuxCB *muxCB, UINT32 muxH
} }
return LOS_OK; return LOS_OK;
} }
//OsMuxBitmapSet 函数用于在互斥量等待队列中设置任务的优先级位图，并根据需要调整任务的优先级，以确保任务在等待互斥量时能够正确反映其优先级关系
LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapSet(const LosTaskCB *runTask, const MuxBaseCB *muxPended) LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapSet(const LosTaskCB *runTask, const MuxBaseCB *muxPended)
{ {
if (muxPended->owner->priority > runTask->priority) { if (muxPended->owner->priority > runTask->priority) {
@ -178,7 +176,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapSet(const LosTaskCB *runTask, const MuxB
OsTaskPriModify(muxPended->owner, runTask->priority); OsTaskPriModify(muxPended->owner, runTask->priority);
} }
} }
//OsMuxBitmapRestore 函数用于恢复任务的优先级位图，并根据需要更新拥有者任务的优先级
LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapRestore(const LosTaskCB *runTask, LosTaskCB *owner) LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapRestore(const LosTaskCB *runTask, LosTaskCB *owner)
{ {
UINT16 bitMapPri; UINT16 bitMapPri;
@ -246,8 +244,7 @@ LITE_OS_SEC_TEXT STATIC LOS_DL_LIST *OsMuxPendFindPos(const LosTaskCB *runTask,
return node; return node;
} }
#endif #endif
//总体来说，OsMuxPostOp 函数用于处理 Mutex 的释放操作，包括唤醒等待任务、更新 Mutex 状态和持有者等
//确保 Mutex 能够按照预期的方式被正确释放和传递给下一个任务
LITE_OS_SEC_TEXT UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UINT32 timeout, LITE_OS_SEC_TEXT UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UINT32 timeout,
UINT32 *intSave) UINT32 *intSave)
{ {
@ -273,7 +270,7 @@ LITE_OS_SEC_TEXT UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UI
return ret; return ret;
} }
//LOS_MuxPend：等待Mutex函数，用于尝试获取指定Mutex的访问权限。如果Mutex已被其他任务持有，则当前任务会被挂起，直到Mutex可用
LITE_OS_SEC_TEXT UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout) LITE_OS_SEC_TEXT UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout)
{ {
UINT32 ret; UINT32 ret;
@ -335,7 +332,7 @@ OUT_UNLOCK:
} }
return ret; return ret;
} }
//OsMuxPostOpSub:通过比较当前任务和 Mutex 等待队列中的任务的优先级，来调整当前任务的优先级位图，并将 Mutex 持有者的优先级提升
LITE_OS_SEC_TEXT STATIC VOID OsMuxPostOpSub(LosTaskCB *runTask, MuxBaseCB *muxPosted) LITE_OS_SEC_TEXT STATIC VOID OsMuxPostOpSub(LosTaskCB *runTask, MuxBaseCB *muxPosted)
{ {
LosTaskCB *pendedTask = NULL; LosTaskCB *pendedTask = NULL;
@ -353,7 +350,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsMuxPostOpSub(LosTaskCB *runTask, MuxBaseCB *muxPo
LOS_BitmapClr(&runTask->priBitMap, bitMapPri); LOS_BitmapClr(&runTask->priBitMap, bitMapPri);
OsTaskPriModify(muxPosted->owner, bitMapPri); OsTaskPriModify(muxPosted->owner, bitMapPri);
} }
//
LITE_OS_SEC_TEXT UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted) LITE_OS_SEC_TEXT UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted)
{ {
LosTaskCB *resumedTask = NULL; LosTaskCB *resumedTask = NULL;
@ -389,7 +386,7 @@ LITE_OS_SEC_TEXT UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted)
return MUX_SCHEDULE; return MUX_SCHEDULE;
} }
//LOS_MuxPost：释放Mutex函数，用于释放当前任务对指定Mutex的访问权限，以便其他任务可以获取该Mutex
LITE_OS_SEC_TEXT UINT32 LOS_MuxPost(UINT32 muxHandle) LITE_OS_SEC_TEXT UINT32 LOS_MuxPost(UINT32 muxHandle)
{ {
UINT32 ret; UINT32 ret;

2
src/kernel/base/los_percpu.c
Unescape View File

@ -33,7 +33,7 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//定义全局变量数组，用于存储每个CPU核心的私有数据
Percpu g_percpu[LOSCFG_KERNEL_CORE_NUM]; Percpu g_percpu[LOSCFG_KERNEL_CORE_NUM];
#ifdef __cplusplus #ifdef __cplusplus

14
src/kernel/base/los_printf.c
Unescape View File

@ -32,7 +32,7 @@
* It should not add OS inner invocation, which is not allowed to be accessed in user space. * It should not add OS inner invocation, which is not allowed to be accessed in user space.
* But it's allowed to invoke syscall interface. * But it's allowed to invoke syscall interface.
*---------------------------------------------------------------------------- */ *---------------------------------------------------------------------------- */
/*这段代码是一个输出控制模块，根据不同的输出类型将字符串输出到不同的设备上*/
#ifdef LOSCFG_LIB_LIBC #ifdef LOSCFG_LIB_LIBC
#include "unistd.h" #include "unistd.h"
#endif #endif
@ -62,13 +62,13 @@ typedef enum {
CONSOLE_OUTPUT = 2, CONSOLE_OUTPUT = 2,
EXC_OUTPUT = 3 EXC_OUTPUT = 3
} OutputType; } OutputType;
//ErrorMsg：用于输出错误信息，当字符串输出非法或者vsnprintf_s函数失败时调用
STATIC VOID ErrorMsg(VOID) STATIC VOID ErrorMsg(VOID)
{ {
const CHAR *p = "Output illegal string! vsnprintf_s failed!\n"; const CHAR *p = "Output illegal string! vsnprintf_s failed!\n";
UartPuts(p, (UINT32)strlen(p), UART_WITH_LOCK); UartPuts(p, (UINT32)strlen(p), UART_WITH_LOCK);
} }
//UartOutput：实际将字符串输出到串口的函数，根据配置可能会进行一些额外的处理
STATIC VOID UartOutput(const CHAR *str, UINT32 len, BOOL isLock) STATIC VOID UartOutput(const CHAR *str, UINT32 len, BOOL isLock)
{ {
#ifdef LOSCFG_SHELL_DMESG #ifdef LOSCFG_SHELL_DMESG
@ -82,7 +82,7 @@ STATIC VOID UartOutput(const CHAR *str, UINT32 len, BOOL isLock)
UartPuts(str, len, isLock); UartPuts(str, len, isLock);
#endif #endif
} }
//OutputControl：根据输出类型选择相应的输出设备，并调用对应的输出函数
STATIC VOID OutputControl(const CHAR *str, UINT32 len, OutputType type) STATIC VOID OutputControl(const CHAR *str, UINT32 len, OutputType type)
{ {
switch (type) { switch (type) {
@ -105,14 +105,14 @@ STATIC VOID OutputControl(const CHAR *str, UINT32 len, OutputType type)
} }
return; return;
} }
//OsVprintfFree：释放动态分配的缓冲区内存
STATIC VOID OsVprintfFree(CHAR *buf, UINT32 bufLen) STATIC VOID OsVprintfFree(CHAR *buf, UINT32 bufLen)
{ {
if (bufLen != SIZEBUF) { if (bufLen != SIZEBUF) {
(VOID)LOS_MemFree(m_aucSysMem0, buf); (VOID)LOS_MemFree(m_aucSysMem0, buf);
} }
} }
//OsVprintf：核心函数，根据给定的格式化字符串和可变参数，进行字符串格式化并输出到相应的设备
STATIC VOID OsVprintf(const CHAR *fmt, va_list ap, OutputType type) STATIC VOID OsVprintf(const CHAR *fmt, va_list ap, OutputType type)
{ {
INT32 len; INT32 len;
@ -156,7 +156,7 @@ STATIC VOID OsVprintf(const CHAR *fmt, va_list ap, OutputType type)
OutputControl(bBuf, len, type); OutputControl(bBuf, len, type);
OsVprintfFree(bBuf, bufLen); OsVprintfFree(bBuf, bufLen);
} }
//UartVprintf、ConsoleVprintf、UartPrintf、dprintf、LkDprintf、DmesgPrintf、ExcPrintf、PrintExcInfo：这些函数都是对OsVprintf的封装，提供了不同的输出接口，在不同的场景下调用OsVprintf来完成字符串的格式化和输出
VOID UartVprintf(const CHAR *fmt, va_list ap) VOID UartVprintf(const CHAR *fmt, va_list ap)
{ {
OsVprintf(fmt, ap, UART_OUTPUT); OsVprintf(fmt, ap, UART_OUTPUT);

39
src/kernel/base/los_queue.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//实现了一个基于轻量级操作系统的队列管理模块，提供了队列的创建、读写、删除以及信息获取等功能
#include "los_queue_pri.h" #include "los_queue_pri.h"
#include "los_queue_debug_pri.h" #include "los_queue_debug_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
@ -53,7 +53,6 @@ LITE_OS_SEC_BSS STATIC LOS_DL_LIST g_freeQueueList;
* Description : queue initial * Description : queue initial
* Return : LOS_OK on success or error code on failure * Return : LOS_OK on success or error code on failure
*/ */
//初始化队列，返回成功或失败错误码
LITE_OS_SEC_TEXT_INIT UINT32 OsQueueInit(VOID) LITE_OS_SEC_TEXT_INIT UINT32 OsQueueInit(VOID)
{ {
LosQueueCB *queueNode = NULL; LosQueueCB *queueNode = NULL;
@ -79,7 +78,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsQueueInit(VOID)
} }
return LOS_OK; return LOS_OK;
} }
//OsQueueCreateParameterCheck函数用于检查创建队列时传入的参数是否合法
STATIC INLINE UINT32 OsQueueCreateParameterCheck(UINT16 len, const UINT32 *queueId, UINT16 maxMsgSize) STATIC INLINE UINT32 OsQueueCreateParameterCheck(UINT16 len, const UINT32 *queueId, UINT16 maxMsgSize)
{ {
if (queueId == NULL) { if (queueId == NULL) {
@ -95,7 +94,7 @@ STATIC INLINE UINT32 OsQueueCreateParameterCheck(UINT16 len, const UINT32 *queue
} }
return LOS_OK; return LOS_OK;
} }
//OsQueueCreateInternal函数用于创建队列，包括在队列控制块中记录队列长度、消息大小等信息
LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsQueueCreateInternal(UINT16 len, UINT32 *queueId, UINT16 msgSize, LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsQueueCreateInternal(UINT16 len, UINT32 *queueId, UINT16 msgSize,
UINT8 *queue, UINT8 queueMemType) UINT8 *queue, UINT8 queueMemType)
{ {
@ -166,7 +165,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueCreateStatic(const CHAR *queueName,
return OsQueueCreateInternal(len, queueId, msgSize, queueMem, OS_QUEUE_ALLOC_STATIC); return OsQueueCreateInternal(len, queueId, msgSize, queueMem, OS_QUEUE_ALLOC_STATIC);
} }
#endif #endif
//创建队列
LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueCreate(const CHAR *queueName, UINT16 len, UINT32 *queueId, LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueCreate(const CHAR *queueName, UINT16 len, UINT32 *queueId,
UINT32 flags, UINT16 maxMsgSize) UINT32 flags, UINT16 maxMsgSize)
{ {
@ -199,7 +198,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueCreate(const CHAR *queueName, UINT16 len,
return LOS_OK; return LOS_OK;
} }
//OsQueueReadParameterCheck和OsQueueWriteParameterCheck分别用于检查读和写操作的参数合法性
LITE_OS_SEC_TEXT STATIC UINT32 OsQueueReadParameterCheck(UINT32 queueId, const VOID *bufferAddr, LITE_OS_SEC_TEXT STATIC UINT32 OsQueueReadParameterCheck(UINT32 queueId, const VOID *bufferAddr,
const UINT32 *bufferSize, UINT32 timeout) const UINT32 *bufferSize, UINT32 timeout)
{ {
@ -249,7 +248,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsQueueWriteParameterCheck(UINT32 queueId, const
} }
return LOS_OK; return LOS_OK;
} }
//实现了队列的读取和写入操作，并对可能出现的错误进行了处理
STATIC UINT32 OsQueueBufferOperate(LosQueueCB *queueCB, UINT32 operateType, VOID *bufferAddr, UINT32 *bufferSize) STATIC UINT32 OsQueueBufferOperate(LosQueueCB *queueCB, UINT32 operateType, VOID *bufferAddr, UINT32 *bufferSize)
{ {
UINT8 *queueNode = NULL; UINT8 *queueNode = NULL;
@ -297,7 +296,7 @@ STATIC UINT32 OsQueueBufferOperate(LosQueueCB *queueCB, UINT32 operateType, VOID
} }
return LOS_OK; return LOS_OK;
} }
//用于处理队列操作函数 OsQueueBufferOperate 返回的错误码,使得在发生错误时能够打印相应的错误信息
STATIC VOID OsQueueBufferOperateErrProcess(UINT32 errorCode) STATIC VOID OsQueueBufferOperateErrProcess(UINT32 errorCode)
{ {
switch (errorCode) { switch (errorCode) {
@ -337,7 +336,7 @@ STATIC UINT32 OsQueueOperateParamCheck(const LosQueueCB *queueCB, UINT32 queueId
} }
return LOS_OK; return LOS_OK;
} }
//OsQueueOperate:实现了对队列的操作，包括参数检查、任务挂起与唤醒以及错误处理等功能
STATIC UINT32 OsQueueOperate(UINT32 queueId, UINT32 operateType, VOID *bufferAddr, UINT32 *bufferSize, UINT32 timeout) STATIC UINT32 OsQueueOperate(UINT32 queueId, UINT32 operateType, VOID *bufferAddr, UINT32 *bufferSize, UINT32 timeout)
{ {
LosQueueCB *queueCB = (LosQueueCB *)GET_QUEUE_HANDLE(queueId); LosQueueCB *queueCB = (LosQueueCB *)GET_QUEUE_HANDLE(queueId);
@ -401,7 +400,7 @@ QUEUE_END:
OsQueueBufferOperateErrProcess(errorCode); OsQueueBufferOperateErrProcess(errorCode);
return ret; return ret;
} }
//LOS_QueueReadCopy：从队列中读取数据，通过参数检查后调用OsQueueOperate函数进行实际的读取操作
LITE_OS_SEC_TEXT UINT32 LOS_QueueReadCopy(UINT32 queueId, LITE_OS_SEC_TEXT UINT32 LOS_QueueReadCopy(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 *bufferSize, UINT32 *bufferSize,
@ -418,7 +417,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_QueueReadCopy(UINT32 queueId,
operateType = OS_QUEUE_OPERATE_TYPE(OS_QUEUE_READ, OS_QUEUE_HEAD); operateType = OS_QUEUE_OPERATE_TYPE(OS_QUEUE_READ, OS_QUEUE_HEAD);
return OsQueueOperate(queueId, operateType, bufferAddr, bufferSize, timeout); return OsQueueOperate(queueId, operateType, bufferAddr, bufferSize, timeout);
} }
//LOS_QueueWriteHeadCopy：向队列的头部写入数据，通过参数检查后调用OsQueueOperate函数进行实际的写入操作
LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteHeadCopy(UINT32 queueId, LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteHeadCopy(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 bufferSize, UINT32 bufferSize,
@ -435,7 +434,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteHeadCopy(UINT32 queueId,
operateType = OS_QUEUE_OPERATE_TYPE(OS_QUEUE_WRITE, OS_QUEUE_HEAD); operateType = OS_QUEUE_OPERATE_TYPE(OS_QUEUE_WRITE, OS_QUEUE_HEAD);
return OsQueueOperate(queueId, operateType, bufferAddr, &bufferSize, timeout); return OsQueueOperate(queueId, operateType, bufferAddr, &bufferSize, timeout);
} }
//LOS_QueueWriteCopy：向队列的尾部写入数据，通过参数检查后调用OsQueueOperate函数进行实际的写入操作
LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteCopy(UINT32 queueId, LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteCopy(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 bufferSize, UINT32 bufferSize,
@ -452,12 +451,12 @@ LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteCopy(UINT32 queueId,
operateType = OS_QUEUE_OPERATE_TYPE(OS_QUEUE_WRITE, OS_QUEUE_TAIL); operateType = OS_QUEUE_OPERATE_TYPE(OS_QUEUE_WRITE, OS_QUEUE_TAIL);
return OsQueueOperate(queueId, operateType, bufferAddr, &bufferSize, timeout); return OsQueueOperate(queueId, operateType, bufferAddr, &bufferSize, timeout);
} }
//LOS_QueueRead：从队列中读取数据的简化接口，直接调用LOS_QueueReadCopy函数
LITE_OS_SEC_TEXT UINT32 LOS_QueueRead(UINT32 queueId, VOID *bufferAddr, UINT32 bufferSize, UINT32 timeout) LITE_OS_SEC_TEXT UINT32 LOS_QueueRead(UINT32 queueId, VOID *bufferAddr, UINT32 bufferSize, UINT32 timeout)
{ {
return LOS_QueueReadCopy(queueId, bufferAddr, &bufferSize, timeout); return LOS_QueueReadCopy(queueId, bufferAddr, &bufferSize, timeout);
} }
//LOS_QueueWrite：向队列中写入数据的简化接口，先进行参数检查，然后调用LOS_QueueWriteCopy函数
LITE_OS_SEC_TEXT UINT32 LOS_QueueWrite(UINT32 queueId, VOID *bufferAddr, UINT32 bufferSize, UINT32 timeout) LITE_OS_SEC_TEXT UINT32 LOS_QueueWrite(UINT32 queueId, VOID *bufferAddr, UINT32 bufferSize, UINT32 timeout)
{ {
if (bufferAddr == NULL) { if (bufferAddr == NULL) {
@ -466,7 +465,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_QueueWrite(UINT32 queueId, VOID *bufferAddr, UINT32
bufferSize = sizeof(CHAR *); bufferSize = sizeof(CHAR *);
return LOS_QueueWriteCopy(queueId, &bufferAddr, bufferSize, timeout); return LOS_QueueWriteCopy(queueId, &bufferAddr, bufferSize, timeout);
} }
//LOS_QueueWriteHead：向队列头部写入数据的简化接口，先进行参数检查，然后调用LOS_QueueWriteHeadCopy函数
LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteHead(UINT32 queueId, LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteHead(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 bufferSize, UINT32 bufferSize,
@ -478,8 +477,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_QueueWriteHead(UINT32 queueId,
bufferSize = sizeof(CHAR *); bufferSize = sizeof(CHAR *);
return LOS_QueueWriteHeadCopy(queueId, &bufferAddr, bufferSize, timeout); return LOS_QueueWriteHeadCopy(queueId, &bufferAddr, bufferSize, timeout);
} }
//LOS_QueueDelete：删除队列的函数
//首先检查队列是否存在，如果存在则检查是否有任务正在使用队列或者队列中还有未释放的内存块，如果满足条件则释放队列所占用的资源
LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueDelete(UINT32 queueId) LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueDelete(UINT32 queueId)
{ {
LosQueueCB *queueCB = NULL; LosQueueCB *queueCB = NULL;
@ -539,7 +537,7 @@ QUEUE_END:
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return ret; return ret;
} }
//LOS_QueueInfoGet:获取指定队列的相关信息，包括队列ID、队列长度、队列大小、队列头尾指针、等待读取和写入的任务数等
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_QueueInfoGet(UINT32 queueId, QUEUE_INFO_S *queueInfo) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_QueueInfoGet(UINT32 queueId, QUEUE_INFO_S *queueInfo)
{ {
UINT32 intSave; UINT32 intSave;
@ -597,9 +595,6 @@ QUEUE_END:
* : timeout --- Expiry time. The value range is [0,LOS_WAIT_FOREVER] * : timeout --- Expiry time. The value range is [0,LOS_WAIT_FOREVER]
* Return : pointer if success otherwise NULL * Return : pointer if success otherwise NULL
*/ */
//OsQueueMailAlloc函数用来从邮件池中分配一个邮件内存块
//如果没有可用的内存块，则根据超时时间挂起当前任务，并将其加入到等待内存块的任务链表中
//当有内存块可用时，会将任务从任务链表中移除，并返回分配的内存块指针
LITE_OS_SEC_TEXT VOID *OsQueueMailAlloc(UINT32 queueId, VOID *mailPool, UINT32 timeout) LITE_OS_SEC_TEXT VOID *OsQueueMailAlloc(UINT32 queueId, VOID *mailPool, UINT32 timeout)
{ {
VOID *mem = NULL; VOID *mem = NULL;
@ -668,8 +663,6 @@ END:
* : mailMem --- The mail memory block address * : mailMem --- The mail memory block address
* Return : LOS_OK on success or error code on failure * Return : LOS_OK on success or error code on failure
*/ */
//OsQueueMailFree函数用来释放指定的邮件内存块，并将其加入到邮件池的空闲链表中
//如果有任务在等待内存块，则会从任务链表中唤醒一个任务，并将其从任务链表中移除
LITE_OS_SEC_TEXT UINT32 OsQueueMailFree(UINT32 queueId, VOID *mailPool, VOID *mailMem) LITE_OS_SEC_TEXT UINT32 OsQueueMailFree(UINT32 queueId, VOID *mailPool, VOID *mailMem)
{ {
VOID *mem = NULL; VOID *mem = NULL;

19
src/kernel/base/los_ringbuf.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*实现环形缓冲区。环形缓冲区是一种循环使用固定大小存储空间的数据结构，常用于解决生产者-消费者问题*/
#include "los_ringbuf.h" #include "los_ringbuf.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -33,7 +33,7 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//LOS_RingbufUsedSize：获取环形缓冲区已使用的大小
UINT32 LOS_RingbufUsedSize(Ringbuf *ringbuf) UINT32 LOS_RingbufUsedSize(Ringbuf *ringbuf)
{ {
UINT32 size; UINT32 size;
@ -56,7 +56,6 @@ UINT32 LOS_RingbufUsedSize(Ringbuf *ringbuf)
* | * |
* endIdx * endIdx
*/ */
//OsRingbufWriteLinear：线性写入数据到环形缓冲区
STATIC UINT32 OsRingbufWriteLinear(Ringbuf *ringbuf, const CHAR *buf, UINT32 size) STATIC UINT32 OsRingbufWriteLinear(Ringbuf *ringbuf, const CHAR *buf, UINT32 size)
{ {
UINT32 cpSize; UINT32 cpSize;
@ -78,7 +77,7 @@ STATIC UINT32 OsRingbufWriteLinear(Ringbuf *ringbuf, const CHAR *buf, UINT32 siz
return cpSize; return cpSize;
} }
//OsRingbufWriteLoop：循环写入数据到环形缓冲区
STATIC UINT32 OsRingbufWriteLoop(Ringbuf *ringbuf, const CHAR *buf, UINT32 size) STATIC UINT32 OsRingbufWriteLoop(Ringbuf *ringbuf, const CHAR *buf, UINT32 size)
{ {
UINT32 right, cpSize; UINT32 right, cpSize;
@ -106,7 +105,7 @@ STATIC UINT32 OsRingbufWriteLoop(Ringbuf *ringbuf, const CHAR *buf, UINT32 size)
return cpSize; return cpSize;
} }
//LOS_RingbufWrite：向环形缓冲区写入数据
UINT32 LOS_RingbufWrite(Ringbuf *ringbuf, const CHAR *buf, UINT32 size) UINT32 LOS_RingbufWrite(Ringbuf *ringbuf, const CHAR *buf, UINT32 size)
{ {
UINT32 cpSize = 0; UINT32 cpSize = 0;
@ -131,7 +130,7 @@ EXIT:
LOS_SpinUnlockRestore(&ringbuf->lock, intSave); LOS_SpinUnlockRestore(&ringbuf->lock, intSave);
return cpSize; return cpSize;
} }
//OsRingbufReadLinear：线性读取环形缓冲区中的数据
STATIC UINT32 OsRingbufReadLinear(Ringbuf *ringbuf, CHAR *buf, UINT32 size) STATIC UINT32 OsRingbufReadLinear(Ringbuf *ringbuf, CHAR *buf, UINT32 size)
{ {
UINT32 cpSize, remain; UINT32 cpSize, remain;
@ -154,7 +153,7 @@ STATIC UINT32 OsRingbufReadLinear(Ringbuf *ringbuf, CHAR *buf, UINT32 size)
return cpSize; return cpSize;
} }
//OsRingbufReadLoop：循环读取环形缓冲区中的数据
STATIC UINT32 OsRingbufReadLoop(Ringbuf *ringbuf, CHAR *buf, UINT32 size) STATIC UINT32 OsRingbufReadLoop(Ringbuf *ringbuf, CHAR *buf, UINT32 size)
{ {
UINT32 right, cpSize; UINT32 right, cpSize;
@ -180,7 +179,7 @@ STATIC UINT32 OsRingbufReadLoop(Ringbuf *ringbuf, CHAR *buf, UINT32 size)
return cpSize; return cpSize;
} }
//LOS_RingbufRead：从环形缓冲区读取数据
UINT32 LOS_RingbufRead(Ringbuf *ringbuf, CHAR *buf, UINT32 size) UINT32 LOS_RingbufRead(Ringbuf *ringbuf, CHAR *buf, UINT32 size)
{ {
UINT32 cpSize; UINT32 cpSize;
@ -206,7 +205,7 @@ EXIT:
LOS_SpinUnlockRestore(&ringbuf->lock, intSave); LOS_SpinUnlockRestore(&ringbuf->lock, intSave);
return cpSize; return cpSize;
} }
//LOS_RingbufInit：初始化环形缓冲区
UINT32 LOS_RingbufInit(Ringbuf *ringbuf, CHAR *fifo, UINT32 size) UINT32 LOS_RingbufInit(Ringbuf *ringbuf, CHAR *fifo, UINT32 size)
{ {
if ((ringbuf == NULL) || (fifo == NULL) || if ((ringbuf == NULL) || (fifo == NULL) ||
@ -222,7 +221,7 @@ UINT32 LOS_RingbufInit(Ringbuf *ringbuf, CHAR *fifo, UINT32 size)
ringbuf->status = RBUF_INITED; ringbuf->status = RBUF_INITED;
return LOS_OK; return LOS_OK;
} }
//LOS_RingbufReset：重置环形缓冲区
VOID LOS_RingbufReset(Ringbuf *ringbuf) VOID LOS_RingbufReset(Ringbuf *ringbuf)
{ {
UINT32 intSave; UINT32 intSave;

23
src/kernel/base/los_sem.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*实现信号量的操作系统内核代码，主要包括信号量的创建、删除、等待（Pend）和释放（Post）等操作*/
#include "los_sem_pri.h" #include "los_sem_pri.h"
#include "los_sem_debug_pri.h" #include "los_sem_debug_pri.h"
#include "los_err_pri.h" #include "los_err_pri.h"
@ -49,7 +49,7 @@ STATIC_INLINE VOID OsSemNodeRecycle(LosSemCB *semNode)
semNode->semStat = LOS_UNUSED; semNode->semStat = LOS_UNUSED;
LOS_ListTailInsert(&g_unusedSemList, &semNode->semList); LOS_ListTailInsert(&g_unusedSemList, &semNode->semList);
} }
//OsSemInit()函数:用于初始化信号量管理模块，包括申请创建信号量所需要的内存空间、将信号量结构体加入到未使用链表中等
LITE_OS_SEC_TEXT_INIT UINT32 OsSemInit(VOID) LITE_OS_SEC_TEXT_INIT UINT32 OsSemInit(VOID)
{ {
LosSemCB *semNode = NULL; LosSemCB *semNode = NULL;
@ -74,8 +74,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSemInit(VOID)
} }
return LOS_OK; return LOS_OK;
} }
//OsSemCreate函数:用于创建一个信号量，并将其加入到已使用信号量列表中
//参数count表示信号量的初始值，type表示信号量的类型（计数信号量或二进制信号量），semHandle用于返回创建的信号量的句柄
LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsSemCreate(UINT16 count, UINT8 type, UINT32 *semHandle) LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsSemCreate(UINT16 count, UINT8 type, UINT32 *semHandle)
{ {
UINT32 intSave; UINT32 intSave;
@ -110,7 +109,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsSemCreate(UINT16 count, UINT8 type, UINT32
LOS_TRACE(SEM_CREATE, semCreated->semId, type, count); LOS_TRACE(SEM_CREATE, semCreated->semId, type, count);
return LOS_OK; return LOS_OK;
} }
//LOS_SemCreate:对外部提供的接口函数，用于创建一个计数信号量
LITE_OS_SEC_TEXT_INIT UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle) LITE_OS_SEC_TEXT_INIT UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle)
{ {
if (count > LOS_SEM_COUNT_MAX) { if (count > LOS_SEM_COUNT_MAX) {
@ -118,7 +117,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle)
} }
return OsSemCreate(count, OS_SEM_COUNTING, semHandle); return OsSemCreate(count, OS_SEM_COUNTING, semHandle);
} }
//LOS_BinarySemCreate:对外部提供的接口函数，用于创建一个二进制信号量
LITE_OS_SEC_TEXT_INIT UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle) LITE_OS_SEC_TEXT_INIT UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle)
{ {
if (count > OS_SEM_BINARY_COUNT_MAX) { if (count > OS_SEM_BINARY_COUNT_MAX) {
@ -126,8 +125,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle
} }
return OsSemCreate(count, OS_SEM_BINARY, semHandle); return OsSemCreate(count, OS_SEM_BINARY, semHandle);
} }
//OsSemStateVerify:用于验证信号量的状态是否有效
//参数semId表示要验证的信号量的ID，semNode是指向信号量控制块的指针
STATIC_INLINE UINT32 OsSemStateVerify(UINT32 semId, const LosSemCB *semNode) STATIC_INLINE UINT32 OsSemStateVerify(UINT32 semId, const LosSemCB *semNode)
{ {
#ifndef LOSCFG_RESOURCE_ID_NOT_USE_HIGH_BITS #ifndef LOSCFG_RESOURCE_ID_NOT_USE_HIGH_BITS
@ -139,8 +137,7 @@ STATIC_INLINE UINT32 OsSemStateVerify(UINT32 semId, const LosSemCB *semNode)
} }
return LOS_OK; return LOS_OK;
} }
//OsSemGetCBWithCheck:用于根据信号量句柄获取信号量的控制块
//参数semHandle表示信号量的句柄，semCB是一个指向指针的指针，用于返回获取到的信号量控制块
STATIC UINT32 OsSemGetCBWithCheck(UINT32 semHandle, LosSemCB **semCB) STATIC UINT32 OsSemGetCBWithCheck(UINT32 semHandle, LosSemCB **semCB)
{ {
if (GET_SEM_INDEX(semHandle) >= (UINT32)KERNEL_SEM_LIMIT) { if (GET_SEM_INDEX(semHandle) >= (UINT32)KERNEL_SEM_LIMIT) {
@ -150,7 +147,7 @@ STATIC UINT32 OsSemGetCBWithCheck(UINT32 semHandle, LosSemCB **semCB)
*semCB = GET_SEM(semHandle); *semCB = GET_SEM(semHandle);
return LOS_OK; return LOS_OK;
} }
//LOS_SemDelete:用于删除指定句柄的信号量，如果有任务正在等待该信号量，则删除失败
LITE_OS_SEC_TEXT_INIT UINT32 LOS_SemDelete(UINT32 semHandle) LITE_OS_SEC_TEXT_INIT UINT32 LOS_SemDelete(UINT32 semHandle)
{ {
UINT32 intSave; UINT32 intSave;
@ -187,7 +184,7 @@ OUT:
LOS_TRACE(SEM_DELETE, semHandle, ret); LOS_TRACE(SEM_DELETE, semHandle, ret);
return ret; return ret;
} }
//LOS_SemPend:用于等待（Pend）一个信号量，如果信号量不可用，则阻塞当前任务直到信号量可用或超时。timeout表示超时时间
LITE_OS_SEC_TEXT UINT32 LOS_SemPend(UINT32 semHandle, UINT32 timeout) LITE_OS_SEC_TEXT UINT32 LOS_SemPend(UINT32 semHandle, UINT32 timeout)
{ {
UINT32 intSave; UINT32 intSave;
@ -255,7 +252,7 @@ OUT:
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return ret; return ret;
} }
//LOS_SemPost:用于释放（Post）一个信号量，使其变为可用状态，并唤醒等待该信号量的任务中的第一个任务
LITE_OS_SEC_TEXT UINT32 LOS_SemPost(UINT32 semHandle) LITE_OS_SEC_TEXT UINT32 LOS_SemPost(UINT32 semHandle)
{ {
UINT32 intSave; UINT32 intSave;

32
src/kernel/base/los_sortlink.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*嵌入式操作系统中与任务调度相关的排序链表管理代码。包括了对排序链表的初始化、向排序链表中添加节点、从排序链表中删除节点、获取下一个超时时间等操作*/
#include "los_sortlink_pri.h" #include "los_sortlink_pri.h"
#include "los_memory.h" #include "los_memory.h"
#include "los_exc.h" #include "los_exc.h"
@ -39,7 +39,7 @@ extern "C" {
#define OS_INVALID_VALUE 0xFFFFFFFF #define OS_INVALID_VALUE 0xFFFFFFFF
#ifdef LOSCFG_BASE_CORE_USE_MULTI_LIST #ifdef LOSCFG_BASE_CORE_USE_MULTI_LIST
//OsSortLinkInit：初始化排序链表，为排序链表的头节点分配内存，并进行初始化
LITE_OS_SEC_TEXT_INIT UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader) LITE_OS_SEC_TEXT_INIT UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
{ {
UINT32 size; UINT32 size;
@ -60,7 +60,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
} }
return LOS_OK; return LOS_OK;
} }
//OsAdd2SortLink：将一个节点添加到排序链表中，根据节点的超时时间计算节点在排序链表中的位置，然后插入到相应位置
LITE_OS_SEC_TEXT VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList) LITE_OS_SEC_TEXT VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
{ {
SortLinkList *listSorted = NULL; SortLinkList *listSorted = NULL;
@ -106,7 +106,7 @@ LITE_OS_SEC_TEXT VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, So
LOS_ListTailInsert(&listSorted->sortLinkNode, &sortList->sortLinkNode); LOS_ListTailInsert(&listSorted->sortLinkNode, &sortList->sortLinkNode);
} }
} }
//OsCheckSortLink：检查排序链表是否合法，排除循环引用和无效节点
LITE_OS_SEC_TEXT STATIC VOID OsCheckSortLink(const LOS_DL_LIST *listHead, const LOS_DL_LIST *listNode) LITE_OS_SEC_TEXT STATIC VOID OsCheckSortLink(const LOS_DL_LIST *listHead, const LOS_DL_LIST *listNode)
{ {
LOS_DL_LIST *tmp = listNode->pstPrev; LOS_DL_LIST *tmp = listNode->pstPrev;
@ -122,7 +122,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsCheckSortLink(const LOS_DL_LIST *listHead, const
/* delete invalid sortlink node */ /* delete invalid sortlink node */
OsBackTrace(); OsBackTrace();
} }
//OsDeleteSortLink：从排序链表中删除一个节点，然后更新相邻节点的超时时间
LITE_OS_SEC_TEXT VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList) LITE_OS_SEC_TEXT VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
{ {
LOS_DL_LIST *listObject = NULL; LOS_DL_LIST *listObject = NULL;
@ -141,7 +141,7 @@ LITE_OS_SEC_TEXT VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader,
} }
LOS_ListDelete(&sortList->sortLinkNode); LOS_ListDelete(&sortList->sortLinkNode);
} }
//OsCalcExpierTime：根据当前的排序链表游标和节点的位置计算超时时间
LITE_OS_SEC_TEXT STATIC INLINE UINT32 OsCalcExpierTime(UINT32 rollNum, UINT32 sortIndex, UINT16 curSortIndex) LITE_OS_SEC_TEXT STATIC INLINE UINT32 OsCalcExpierTime(UINT32 rollNum, UINT32 sortIndex, UINT16 curSortIndex)
{ {
UINT32 expireTime; UINT32 expireTime;
@ -154,7 +154,7 @@ LITE_OS_SEC_TEXT STATIC INLINE UINT32 OsCalcExpierTime(UINT32 rollNum, UINT32 so
expireTime = ((rollNum - 1) << OS_TSK_SORTLINK_LOGLEN) + sortIndex; expireTime = ((rollNum - 1) << OS_TSK_SORTLINK_LOGLEN) + sortIndex;
return expireTime; return expireTime;
} }
//OsSortLinkGetNextExpireTime：获取排序链表中下一个超时时间最小的节点的超时时间
LITE_OS_SEC_TEXT UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader) LITE_OS_SEC_TEXT UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader)
{ {
UINT16 cursor; UINT16 cursor;
@ -184,7 +184,7 @@ LITE_OS_SEC_TEXT UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sor
return expireTime; return expireTime;
} }
//OsSortLinkUpdateExpireTime：更新排序链表中所有节点的超时时间，并更新游标
LITE_OS_SEC_TEXT VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttribute *sortLinkHeader) LITE_OS_SEC_TEXT VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttribute *sortLinkHeader)
{ {
SortLinkList *sortList = NULL; SortLinkList *sortList = NULL;
@ -215,7 +215,7 @@ LITE_OS_SEC_TEXT VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttr
} }
sortLinkHeader->cursor = (sortLinkHeader->cursor + sleepTicks - 1) % OS_TSK_SORTLINK_LEN; sortLinkHeader->cursor = (sortLinkHeader->cursor + sleepTicks - 1) % OS_TSK_SORTLINK_LEN;
} }
//OsSortLinkGetTargetExpireTime：获取目标节点的超时时间
LITE_OS_SEC_TEXT_MINOR UINT32 OsSortLinkGetTargetExpireTime(const SortLinkAttribute *sortLinkHeader, LITE_OS_SEC_TEXT_MINOR UINT32 OsSortLinkGetTargetExpireTime(const SortLinkAttribute *sortLinkHeader,
const SortLinkList *targetSortList) const SortLinkList *targetSortList)
{ {
@ -235,7 +235,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsSortLinkGetTargetExpireTime(const SortLinkAttrib
} }
#else /* LOSCFG_BASE_CORE_USE_SINGLE_LIST */ #else /* LOSCFG_BASE_CORE_USE_SINGLE_LIST */
//OsSortLinkInit:初始化排序链表头部
LITE_OS_SEC_TEXT_INIT UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader) LITE_OS_SEC_TEXT_INIT UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
{ {
UINT32 size; UINT32 size;
@ -252,7 +252,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
LOS_ListInit(listObject); LOS_ListInit(listObject);
return LOS_OK; return LOS_OK;
} }
//OsAdd2SortLink:向排序链表中添加元素
LITE_OS_SEC_TEXT VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList) LITE_OS_SEC_TEXT VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
{ {
SortLinkList *listSorted = NULL; SortLinkList *listSorted = NULL;
@ -286,7 +286,7 @@ LITE_OS_SEC_TEXT VOID OsAdd2SortLink(const SortLinkAttribute *sortLinkHeader, So
LOS_ListTailInsert(&listSorted->sortLinkNode, &sortList->sortLinkNode); LOS_ListTailInsert(&listSorted->sortLinkNode, &sortList->sortLinkNode);
} }
} }
//OsCheckSortLink:检查排序链表的有效性，用于内部调用
LITE_OS_SEC_TEXT STATIC VOID OsCheckSortLink(const LOS_DL_LIST *listHead, const LOS_DL_LIST *listNode) LITE_OS_SEC_TEXT STATIC VOID OsCheckSortLink(const LOS_DL_LIST *listHead, const LOS_DL_LIST *listNode)
{ {
LOS_DL_LIST *tmp = listNode->pstPrev; LOS_DL_LIST *tmp = listNode->pstPrev;
@ -302,7 +302,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsCheckSortLink(const LOS_DL_LIST *listHead, const
/* delete invalid sortlink node */ /* delete invalid sortlink node */
OsBackTrace(); OsBackTrace();
} }
//OsDeleteSortLink:从排序链表中删除指定元素
LITE_OS_SEC_TEXT VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList) LITE_OS_SEC_TEXT VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
{ {
LOS_DL_LIST *listObject = NULL; LOS_DL_LIST *listObject = NULL;
@ -319,7 +319,7 @@ LITE_OS_SEC_TEXT VOID OsDeleteSortLink(const SortLinkAttribute *sortLinkHeader,
} }
LOS_ListDelete(&sortList->sortLinkNode); LOS_ListDelete(&sortList->sortLinkNode);
} }
//OsSortLinkGetNextExpireTime:获取排序链表中下一个到期的时间
LITE_OS_SEC_TEXT UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader) LITE_OS_SEC_TEXT UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader)
{ {
UINT32 expireTime = OS_INVALID_VALUE; UINT32 expireTime = OS_INVALID_VALUE;
@ -333,7 +333,7 @@ LITE_OS_SEC_TEXT UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sor
} }
return expireTime; return expireTime;
} }
//OsSortLinkUpdateExpireTime:更新排序链表中到期时间
LITE_OS_SEC_TEXT VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttribute *sortLinkHeader) LITE_OS_SEC_TEXT VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttribute *sortLinkHeader)
{ {
SortLinkList *sortList = NULL; SortLinkList *sortList = NULL;
@ -349,7 +349,7 @@ LITE_OS_SEC_TEXT VOID OsSortLinkUpdateExpireTime(UINT32 sleepTicks, SortLinkAttr
ROLLNUM_SUB(sortList->idxRollNum, sleepTicks - 1); ROLLNUM_SUB(sortList->idxRollNum, sleepTicks - 1);
} }
} }
//OsSortLinkGetTargetExpireTime:获取指定排序链表元素的到期时间
LITE_OS_SEC_TEXT_MINOR UINT32 OsSortLinkGetTargetExpireTime(const SortLinkAttribute *sortLinkHeader, LITE_OS_SEC_TEXT_MINOR UINT32 OsSortLinkGetTargetExpireTime(const SortLinkAttribute *sortLinkHeader,
const SortLinkList *targetSortList) const SortLinkList *targetSortList)
{ {

10
src/kernel/base/los_stackinfo.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//栈
#include "securec.h" #include "securec.h"
#include "los_stackinfo_pri.h" #include "los_stackinfo_pri.h"
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
@ -35,7 +35,7 @@
const StackInfo *g_stackInfo = NULL; const StackInfo *g_stackInfo = NULL;
UINT32 g_stackNum; UINT32 g_stackNum;
//OsStackWaterLineGet:获取栈的使用情况
UINT32 OsStackWaterLineGet(const UINTPTR *stackBottom, const UINTPTR *stackTop, UINT32 *peakUsed) UINT32 OsStackWaterLineGet(const UINTPTR *stackBottom, const UINTPTR *stackTop, UINT32 *peakUsed)
{ {
UINT32 size; UINT32 size;
@ -53,20 +53,20 @@ UINT32 OsStackWaterLineGet(const UINTPTR *stackBottom, const UINTPTR *stackTop,
return LOS_NOK; return LOS_NOK;
} }
} }
//OsExcStackInfoReg:注册异常栈信息
VOID OsExcStackInfoReg(const StackInfo *stackInfo, UINT32 stackNum) VOID OsExcStackInfoReg(const StackInfo *stackInfo, UINT32 stackNum)
{ {
g_stackInfo = stackInfo; g_stackInfo = stackInfo;
g_stackNum = stackNum; g_stackNum = stackNum;
} }
//OsStackInit:初始化任务栈
VOID OsStackInit(VOID *stacktop, UINT32 stacksize) VOID OsStackInit(VOID *stacktop, UINT32 stacksize)
{ {
/* initialize the task stack, write magic num to stack top */ /* initialize the task stack, write magic num to stack top */
(VOID)memset_s(stacktop, stacksize, (INT32)OS_STACK_INIT, stacksize); (VOID)memset_s(stacktop, stacksize, (INT32)OS_STACK_INIT, stacksize);
*((UINTPTR *)stacktop) = OS_STACK_MAGIC_WORD; *((UINTPTR *)stacktop) = OS_STACK_MAGIC_WORD;
} }
//OsGetStackInfo:获取栈信息
VOID OsGetStackInfo(const StackInfo **stackInfo, UINT32 *stackNum) VOID OsGetStackInfo(const StackInfo **stackInfo, UINT32 *stackNum)
{ {
*stackInfo = g_stackInfo; *stackInfo = g_stackInfo;

25
src/kernel/base/los_swtmr.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*软件定时器的实现，涉及软件定时器的创建、启动、停止、删除等操作*/
#include "los_swtmr_pri.h" #include "los_swtmr_pri.h"
#include "los_sortlink_pri.h" #include "los_sortlink_pri.h"
#include "los_queue_pri.h" #include "los_queue_pri.h"
@ -52,7 +52,6 @@ LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_swtmrSpin);
* Description: Start Software Timer * Description: Start Software Timer
* Input : swtmr --- Need to start software timer * Input : swtmr --- Need to start software timer
*/ */
//OsSwtmrStart：启动软件定时器
LITE_OS_SEC_TEXT VOID OsSwtmrStart(LosSwtmrCB *swtmr) LITE_OS_SEC_TEXT VOID OsSwtmrStart(LosSwtmrCB *swtmr)
{ {
if ((swtmr->overrun == 0) && ((swtmr->mode == LOS_SWTMR_MODE_ONCE) || if ((swtmr->overrun == 0) && ((swtmr->mode == LOS_SWTMR_MODE_ONCE) ||
@ -76,14 +75,13 @@ LITE_OS_SEC_TEXT VOID OsSwtmrStart(LosSwtmrCB *swtmr)
* Description: Delete Software Timer * Description: Delete Software Timer
* Input : swtmr --- Need to delete software timer, When using, Ensure that it can't be NULL. * Input : swtmr --- Need to delete software timer, When using, Ensure that it can't be NULL.
*/ */
//OsSwtmrDelete：删除软件定时器
STATIC INLINE VOID OsSwtmrDelete(LosSwtmrCB *swtmr) STATIC INLINE VOID OsSwtmrDelete(LosSwtmrCB *swtmr)
{ {
/* insert to free list */ /* insert to free list */
LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->sortList.sortLinkNode); LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->sortList.sortLinkNode);
swtmr->state = OS_SWTMR_STATUS_UNUSED; swtmr->state = OS_SWTMR_STATUS_UNUSED;
} }
//OsSwtmrUpdate：更新软件定时器
STATIC INLINE VOID OsSwtmrUpdate(LosSwtmrCB *swtmr) STATIC INLINE VOID OsSwtmrUpdate(LosSwtmrCB *swtmr)
{ {
if (swtmr->mode == LOS_SWTMR_MODE_ONCE) { if (swtmr->mode == LOS_SWTMR_MODE_ONCE) {
@ -103,7 +101,6 @@ STATIC INLINE VOID OsSwtmrUpdate(LosSwtmrCB *swtmr)
} }
#ifndef LOSCFG_BASE_CORE_SWTMR_IN_ISR #ifndef LOSCFG_BASE_CORE_SWTMR_IN_ISR
//OsSwtmrTask：软件定时器任务处理函数，用于处理定时器超时事件
LITE_OS_SEC_TEXT VOID OsSwtmrTask(VOID) LITE_OS_SEC_TEXT VOID OsSwtmrTask(VOID)
{ {
UINT32 ret, swtmrHandlerQueue; UINT32 ret, swtmrHandlerQueue;
@ -139,7 +136,7 @@ BOOL IsSwtmrTask(UINT32 taskId)
return FALSE; return FALSE;
} }
#endif #endif
//OsSwtmrTaskCreate：创建软件定时器任务
LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrTaskCreate(VOID) LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrTaskCreate(VOID)
{ {
UINT32 ret, swtmrTaskId; UINT32 ret, swtmrTaskId;
@ -164,7 +161,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrTaskCreate(VOID)
return ret; return ret;
} }
#endif #endif
//OsSwtmrInit：软件定时器初始化
LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID) LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
{ {
UINT32 size; UINT32 size;
@ -212,7 +209,6 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
* Description: Tick interrupt interface module of software timer * Description: Tick interrupt interface module of software timer
* Return : LOS_OK on success or error code on failure * Return : LOS_OK on success or error code on failure
*/ */
//OsSwtmrScan：扫描软件定时器
LITE_OS_SEC_TEXT VOID OsSwtmrScan(VOID) LITE_OS_SEC_TEXT VOID OsSwtmrScan(VOID)
{ {
SortLinkList *sortList = NULL; SortLinkList *sortList = NULL;
@ -281,7 +277,6 @@ LITE_OS_SEC_TEXT VOID OsSwtmrScan(VOID)
* Description: Get next timeout * Description: Get next timeout
* Return : Count of the Timer list * Return : Count of the Timer list
*/ */
//OsSwtmrGetNextTimeout：获取下一个超时时间
LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID) LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
{ {
return OsSortLinkGetNextExpireTime(&OsPercpuGet()->swtmrSortLink); return OsSortLinkGetNextExpireTime(&OsPercpuGet()->swtmrSortLink);
@ -291,7 +286,6 @@ LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
* Description: Stop of Software Timer interface * Description: Stop of Software Timer interface
* Input : swtmr --- the software timer control handler * Input : swtmr --- the software timer control handler
*/ */
//OsSwtmrStop：停止软件定时器
LITE_OS_SEC_TEXT STATIC VOID OsSwtmrStop(LosSwtmrCB *swtmr) LITE_OS_SEC_TEXT STATIC VOID OsSwtmrStop(LosSwtmrCB *swtmr)
{ {
SortLinkAttribute *sortLinkHeader = NULL; SortLinkAttribute *sortLinkHeader = NULL;
@ -315,7 +309,6 @@ LITE_OS_SEC_TEXT STATIC VOID OsSwtmrStop(LosSwtmrCB *swtmr)
* Description: Get next software timer expiretime * Description: Get next software timer expiretime
* Input : swtmr --- the software timer control handler * Input : swtmr --- the software timer control handler
*/ */
//获取指定软件定时器的剩余时间
LITE_OS_SEC_TEXT STATIC UINT32 OsSwtmrTimeGet(const LosSwtmrCB *swtmr) LITE_OS_SEC_TEXT STATIC UINT32 OsSwtmrTimeGet(const LosSwtmrCB *swtmr)
{ {
SortLinkAttribute *sortLinkHeader = NULL; SortLinkAttribute *sortLinkHeader = NULL;
@ -332,7 +325,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsSwtmrTimeGet(const LosSwtmrCB *swtmr)
return OsSortLinkGetTargetExpireTime(sortLinkHeader, &swtmr->sortList); return OsSortLinkGetTargetExpireTime(sortLinkHeader, &swtmr->sortList);
} }
//创建一个软件定时器
LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval, LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,
UINT8 mode, UINT8 mode,
SWTMR_PROC_FUNC handler, SWTMR_PROC_FUNC handler,
@ -384,7 +377,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,
return LOS_OK; return LOS_OK;
} }
//启动一个软件定时器
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT16 swtmrId) LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT16 swtmrId)
{ {
LosSwtmrCB *swtmr = NULL; LosSwtmrCB *swtmr = NULL;
@ -428,7 +421,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT16 swtmrId)
LOS_TRACE(SWTMR_START, swtmr->timerId, swtmr->mode, swtmr->overrun, swtmr->interval, swtmr->expiry); LOS_TRACE(SWTMR_START, swtmr->timerId, swtmr->mode, swtmr->overrun, swtmr->interval, swtmr->expiry);
return ret; return ret;
} }
//停止一个软件定时器
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStop(UINT16 swtmrId) LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStop(UINT16 swtmrId)
{ {
LosSwtmrCB *swtmr = NULL; LosSwtmrCB *swtmr = NULL;
@ -468,7 +461,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStop(UINT16 swtmrId)
LOS_TRACE(SWTMR_STOP, swtmr->timerId); LOS_TRACE(SWTMR_STOP, swtmr->timerId);
return ret; return ret;
} }
//获取一个软件定时器的剩余时间
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrTimeGet(UINT16 swtmrId, UINT32 *tick) LITE_OS_SEC_TEXT UINT32 LOS_SwtmrTimeGet(UINT16 swtmrId, UINT32 *tick)
{ {
LosSwtmrCB *swtmr = NULL; LosSwtmrCB *swtmr = NULL;
@ -509,7 +502,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrTimeGet(UINT16 swtmrId, UINT32 *tick)
SWTMR_UNLOCK(intSave); SWTMR_UNLOCK(intSave);
return ret; return ret;
} }
//删除一个软件定时器
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrDelete(UINT16 swtmrId) LITE_OS_SEC_TEXT UINT32 LOS_SwtmrDelete(UINT16 swtmrId)
{ {
LosSwtmrCB *swtmr = NULL; LosSwtmrCB *swtmr = NULL;

62
src/kernel/base/los_task.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*关于LiteOS中任务管理模块的部分实现，包括任务控制块的初始化、任务创建、任务删除等功能*/
#include "los_task_pri.h" #include "los_task_pri.h"
#include "los_priqueue_pri.h" #include "los_priqueue_pri.h"
#include "los_sem_pri.h" #include "los_sem_pri.h"
@ -282,7 +282,7 @@ LITE_OS_SEC_TEXT VOID OsTaskScan(VOID)
LOS_Schedule(); LOS_Schedule();
} }
} }
//OsTaskInit用于初始化任务管理模块，包括任务控制块数组、空闲任务列表、任务回收列表等数据结构的初始化
LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID) LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
{ {
UINT32 index; UINT32 index;
@ -335,7 +335,7 @@ UINT32 OsGetIdleTaskId(VOID)
Percpu *perCpu = OsPercpuGet(); Percpu *perCpu = OsPercpuGet();
return perCpu->idleTaskId; return perCpu->idleTaskId;
} }
//创建空闲任务（Idle Task）
LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID) LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
{ {
UINT32 ret; UINT32 ret;
@ -363,7 +363,6 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
* Description : get id of current running task. * Description : get id of current running task.
* Return : task id * Return : task id
*/ */
//读取任务ID
LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID) LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
{ {
LosTaskCB *runTask = OsCurrTaskGet(); LosTaskCB *runTask = OsCurrTaskGet();
@ -373,7 +372,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
} }
return runTask->taskId; return runTask->taskId;
} }
//获取当前正在运行的任务的任务名称
LITE_OS_SEC_TEXT CHAR *OsCurTaskNameGet(VOID) LITE_OS_SEC_TEXT CHAR *OsCurTaskNameGet(VOID)
{ {
LosTaskCB *runTask = OsCurrTaskGet(); LosTaskCB *runTask = OsCurrTaskGet();
@ -429,12 +428,12 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_LowpowerHookReg(LOWPOWERIDLEHOOK hook)
g_lowPowerHook = hook; g_lowPowerHook = hook;
} }
#endif #endif
//注册空闲任务钩子函数，即在系统空闲时执行的函数
LITE_OS_SEC_TEXT_MINOR VOID LOS_IdleHandlerHookReg(IDLEHANDLERHOOK hook) LITE_OS_SEC_TEXT_MINOR VOID LOS_IdleHandlerHookReg(IDLEHANDLERHOOK hook)
{ {
g_idleHandlerHook = hook; g_idleHandlerHook = hook;
} }
//检查任务是否分离（detached）
STATIC BOOL OsTaskDeleteCheckDetached(const LosTaskCB *taskCB) STATIC BOOL OsTaskDeleteCheckDetached(const LosTaskCB *taskCB)
{ {
#if LOSCFG_COMPAT_POSIX #if LOSCFG_COMPAT_POSIX
@ -443,7 +442,7 @@ STATIC BOOL OsTaskDeleteCheckDetached(const LosTaskCB *taskCB)
return TRUE; return TRUE;
#endif #endif
} }
//删除已分离的任务
STATIC VOID OsTaskDeleteDetached(const LosTaskCB *taskCB) STATIC VOID OsTaskDeleteDetached(const LosTaskCB *taskCB)
{ {
UINT32 intSave; UINT32 intSave;
@ -452,7 +451,7 @@ STATIC VOID OsTaskDeleteDetached(const LosTaskCB *taskCB)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
(VOID)LOS_TaskDelete(taskCB->taskId); (VOID)LOS_TaskDelete(taskCB->taskId);
} }
//删除已加入的任务
STATIC VOID OsTaskDeleteJoined(LosTaskCB *taskCB, VOID *ret) STATIC VOID OsTaskDeleteJoined(LosTaskCB *taskCB, VOID *ret)
{ {
#ifdef LOSCFG_COMPAT_POSIX #ifdef LOSCFG_COMPAT_POSIX
@ -482,8 +481,6 @@ STATIC VOID OsTaskDeleteJoined(LosTaskCB *taskCB, VOID *ret)
* Description : All task entry * Description : All task entry
* Input : taskId --- The ID of the task to be run * Input : taskId --- The ID of the task to be run
*/ */
//执行任务的实际代码，并根据任务的属性判断是否需要删除任务
//如果任务是分离的，则直接删除任务；如果任务是加入的，则将任务加入的其他任务唤醒，并重新调度任务
LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskId) LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskId)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
@ -514,7 +511,7 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskId)
OsTaskDeleteJoined(taskCB, ret); OsTaskDeleteJoined(taskCB, ret);
} }
} }
//对任务初始化参数进行检查，确保任务参数的合法性
STATIC UINT32 OsTaskInitParamCheck(const TSK_INIT_PARAM_S *initParam) STATIC UINT32 OsTaskInitParamCheck(const TSK_INIT_PARAM_S *initParam)
{ {
if (initParam == NULL) { if (initParam == NULL) {
@ -569,7 +566,7 @@ STATIC UINT32 OsTaskCreateParamCheckStatic(const UINT32 *taskId,
return LOS_OK; return LOS_OK;
} }
#endif #endif
//对任务创建参数进行检查，确保参数的合法性。如果参数不合法，则返回相应的错误码；否则返回成功
LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskId, LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskId,
TSK_INIT_PARAM_S *initParam, VOID **pool) TSK_INIT_PARAM_S *initParam, VOID **pool)
{ {
@ -779,7 +776,6 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskDelAction(LosTaskCB *taskCB, BOOL useUsr
* 3. Do the deletion in hard-irq * 3. Do the deletion in hard-irq
* then LOS_TaskDelete will directly return with 'ret' value. * then LOS_TaskDelete will directly return with 'ret' value.
*/ */
//OsTaskDeleteCheckOnRun函数用来检查是否需要在任务运行时进行删除操作
LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskDeleteCheckOnRun(LosTaskCB *taskCB, UINT32 *ret) LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskDeleteCheckOnRun(LosTaskCB *taskCB, UINT32 *ret)
{ {
/* init default out return value */ /* init default out return value */
@ -817,7 +813,7 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskDeleteCheckOnRun(LosTaskCB *taskCB, UINT
return TRUE; return TRUE;
} }
//OsTaskCBInit函数用于初始化任务控制块，设置任务的各种属性和状态
LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam, LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam,
VOID *stackPtr, const VOID *topStack, BOOL useUsrStack) VOID *stackPtr, const VOID *topStack, BOOL useUsrStack)
{ {
@ -873,7 +869,7 @@ LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT
(VOID)memset_s(&taskCB->schedStat, sizeof(SchedStat), 0, sizeof(SchedStat)); (VOID)memset_s(&taskCB->schedStat, sizeof(SchedStat), 0, sizeof(SchedStat));
#endif #endif
} }
//OsTaskGetFreeTaskCB函数用于获取一个空闲的任务控制块
STATIC UINT32 OsTaskGetFreeTaskCB(LosTaskCB **taskCB) STATIC UINT32 OsTaskGetFreeTaskCB(LosTaskCB **taskCB)
{ {
if (LOS_ListEmpty(&g_losFreeTask)) { if (LOS_ListEmpty(&g_losFreeTask)) {
@ -887,7 +883,7 @@ STATIC UINT32 OsTaskGetFreeTaskCB(LosTaskCB **taskCB)
LOS_ListDelete(LOS_DL_LIST_FIRST(&g_losFreeTask)); LOS_ListDelete(LOS_DL_LIST_FIRST(&g_losFreeTask));
return LOS_OK; return LOS_OK;
} }
//OsTaskCreateOnly函数用于创建一个新的任务，其中会对参数进行合法性检查
STATIC UINT32 OsTaskCreateOnly(UINT32 *taskId, TSK_INIT_PARAM_S *initParam, VOID *topStack, BOOL useUsrStack) STATIC UINT32 OsTaskCreateOnly(UINT32 *taskId, TSK_INIT_PARAM_S *initParam, VOID *topStack, BOOL useUsrStack)
{ {
UINT32 intSave, errRet; UINT32 intSave, errRet;
@ -951,7 +947,7 @@ LOS_ERREND:
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return errRet; return errRet;
} }
//OsTaskResume函数用于恢复一个被挂起的任务
STATIC VOID OsTaskResume(const UINT32 *taskId) STATIC VOID OsTaskResume(const UINT32 *taskId)
{ {
UINT32 intSave; UINT32 intSave;
@ -1002,8 +998,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskId, TSK_INIT_PARAM_S
{ {
return OsTaskCreateOnly(taskId, initParam, NULL, FALSE); return OsTaskCreateOnly(taskId, initParam, NULL, FALSE);
} }
//LOS_TaskCreate该函数用于创建一个新的任务，包括任务的名称、优先级、栈大小等参数的设置
//在创建任务时，需要进行一些参数的合法性检查，例如是否超出最大任务数量、是否有足够的堆栈空间等
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskId, TSK_INIT_PARAM_S *initParam) LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskId, TSK_INIT_PARAM_S *initParam)
{ {
UINT32 ret; UINT32 ret;
@ -1017,8 +1012,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskId, TSK_INIT_PARAM_S *in
return LOS_OK; return LOS_OK;
} }
//LOS_TaskDelete用于删除一个已经存在的任务
//在删除任务时，需要对任务的状态进行判断。如果任务正在运行，则将其标记为删除状态并放入回收列表；否则直接释放任务占用的资源
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskId) LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskId)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
@ -1078,7 +1072,7 @@ LOS_RETURN:
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return errRet; return errRet;
} }
//LOS_TaskResume函数用于恢复一个挂起的任务
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskId) LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskId)
{ {
UINT32 intSave; UINT32 intSave;
@ -1142,7 +1136,6 @@ LOS_ERREND:
* 3. Do the suspension in hard-irq * 3. Do the suspension in hard-irq
* then LOS_TaskSuspend will directly return with 'ret' value. * then LOS_TaskSuspend will directly return with 'ret' value.
*/ */
//OsTaskSuspendCheckOnRun：检查当前任务是否需要挂起的函数，根据条件判断是否需要进行任务挂起操作
LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UINT32 *ret) LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UINT32 *ret)
{ {
/* init default out return value */ /* init default out return value */
@ -1171,8 +1164,7 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UIN
return TRUE; return TRUE;
} }
//LOS_TaskSuspend：挂起指定任务的函数
//如果任务已经处于挂起状态或者正在运行，并且不满足挂起条件，则直接返回错误码；否则执行挂起操作
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskId) LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskId)
{ {
UINT32 intSave; UINT32 intSave;
@ -1226,7 +1218,7 @@ LOS_RETURN:
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return errRet; return errRet;
} }
//LOS_TaskDelay该函数用于让任务进入延时状态，在指定的时间后重新被调度执行
LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick) LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
{ {
UINT32 intSave; UINT32 intSave;
@ -1258,7 +1250,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
return LOS_OK; return LOS_OK;
} }
//LOS_TaskDelay：将任务进入延时状态，在指定的时间后重新被调度执行，如果当前在中断中或者不可抢占，则返回相应的错误码
LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskId) LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskId)
{ {
UINT32 intSave; UINT32 intSave;
@ -1281,7 +1273,7 @@ LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskId)
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return priority; return priority;
} }
//LOS_TaskPriGet：获取指定任务的优先级
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskId, UINT16 taskPrio) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskId, UINT16 taskPrio)
{ {
BOOL isReady = FALSE; BOOL isReady = FALSE;
@ -1333,7 +1325,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskId, UINT16 taskPrio)
} }
return LOS_OK; return LOS_OK;
} }
//LOS_TaskPriSet：设置指定任务的优先级，根据任务当前状态选择不同的处理方式
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CurTaskPriSet(UINT16 taskPrio) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CurTaskPriSet(UINT16 taskPrio)
{ {
return LOS_TaskPriSet(OsCurrTaskGet()->taskId, taskPrio); return LOS_TaskPriSet(OsCurrTaskGet()->taskId, taskPrio);
@ -1345,7 +1337,6 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CurTaskPriSet(UINT16 taskPrio)
* taskStatus --- task status * taskStatus --- task status
* timeOut --- Expiry time * timeOut --- Expiry time
* Return : LOS_OK on success or LOS_NOK on failure * Return : LOS_OK on success or LOS_NOK on failure
* OsTaskWait和OsTaskWake：任务等待和唤醒的辅助函数
*/ */
VOID OsTaskWait(LOS_DL_LIST *list, UINT16 taskStatus, UINT32 timeout) VOID OsTaskWait(LOS_DL_LIST *list, UINT16 taskStatus, UINT32 timeout)
{ {
@ -1382,7 +1373,7 @@ VOID OsTaskWake(LosTaskCB *resumedTask, UINT16 taskStatus)
OsPriQueueEnqueue(&resumedTask->pendList, resumedTask->priority); OsPriQueueEnqueue(&resumedTask->pendList, resumedTask->priority);
} }
} }
//LOS_TaskYield用于使当前任务主动放弃 CPU 控制权，让出 CPU 给其他高优先级任务执行
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskYield(VOID) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskYield(VOID)
{ {
UINT32 tskCount; UINT32 tskCount;
@ -1421,8 +1412,6 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskYield(VOID)
return LOS_OK; return LOS_OK;
} }
//LOS_TaskLock和LOS_TaskUnlock：任务锁定和解锁函数，用于保护临界区
LITE_OS_SEC_TEXT_MINOR VOID LOS_TaskLock(VOID) LITE_OS_SEC_TEXT_MINOR VOID LOS_TaskLock(VOID)
{ {
UINT32 intSave; UINT32 intSave;
@ -1457,7 +1446,7 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_TaskUnlock(VOID)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
//LOS_TaskInfoGet：获取指定任务的信息，包括任务名、栈大小、堆栈使用情况等
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskId, TSK_INFO_S *taskInfo) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskId, TSK_INFO_S *taskInfo)
{ {
UINT32 intSave; UINT32 intSave;
@ -1514,7 +1503,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskId, TSK_INFO_S *taskInf
return LOS_OK; return LOS_OK;
} }
//LOS_TaskCpuAffiSet和LOS_TaskCpuAffiGet：设置和获取任务的 CPU 亲和性，仅在支持多核的情况下有效
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuAffiSet(UINT32 taskId, UINT16 cpuAffiMask) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuAffiSet(UINT32 taskId, UINT16 cpuAffiMask)
{ {
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
@ -1591,7 +1580,6 @@ LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskCpuAffiGet(UINT32 taskId)
/* /*
* Description : Process pending signals tagged by others cores * Description : Process pending signals tagged by others cores
*OsTaskProcSignal：处理挂起、删除任务等信号
*/ */
LITE_OS_SEC_TEXT_MINOR UINT32 OsTaskProcSignal(VOID) LITE_OS_SEC_TEXT_MINOR UINT32 OsTaskProcSignal(VOID)
{ {

23
src/kernel/base/los_tick.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*时钟模块:主要包括系统时钟的初始化、时钟中断处理函数、获取系统tick数等功能*/
#include "los_tick_pri.h" #include "los_tick_pri.h"
#include "los_swtmr_pri.h" #include "los_swtmr_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
@ -52,7 +52,6 @@ STATIC WAKEUPFROMINTHOOK g_tickWakeupHook = NULL;
/* /*
* Description : Tick interruption handler * Description : Tick interruption handler
*/ */
//OsTickHandler函数：时钟中断处理函数，用于处理时钟中断事件。
LITE_OS_SEC_TEXT VOID OsTickHandler(VOID) LITE_OS_SEC_TEXT VOID OsTickHandler(VOID)
{ {
UINT32 intSave; UINT32 intSave;
@ -77,7 +76,7 @@ LITE_OS_SEC_TEXT VOID OsTickHandler(VOID)
OsSwtmrScan(); OsSwtmrScan();
#endif #endif
} }
//OsTickInit：初始化系统时钟
LITE_OS_SEC_TEXT_INIT UINT32 OsTickInit(UINT32 systemClock, UINT32 tickPerSecond) LITE_OS_SEC_TEXT_INIT UINT32 OsTickInit(UINT32 systemClock, UINT32 tickPerSecond)
{ {
if ((systemClock == 0) || if ((systemClock == 0) ||
@ -89,12 +88,12 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsTickInit(UINT32 systemClock, UINT32 tickPerSecond
return LOS_OK; return LOS_OK;
} }
//启动系统时钟
LITE_OS_SEC_TEXT_INIT VOID OsTickStart(VOID) LITE_OS_SEC_TEXT_INIT VOID OsTickStart(VOID)
{ {
HalClockStart(); HalClockStart();
} }
//LOS_TickCountGet函数：获取系统tick数
LITE_OS_SEC_TEXT_MINOR UINT64 LOS_TickCountGet(VOID) LITE_OS_SEC_TEXT_MINOR UINT64 LOS_TickCountGet(VOID)
{ {
UINT32 intSave; UINT32 intSave;
@ -110,12 +109,12 @@ LITE_OS_SEC_TEXT_MINOR UINT64 LOS_TickCountGet(VOID)
return tick; return tick;
} }
//LOS_CyclePerTickGet函数：获取每个tick所对应的CPU周期数
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CyclePerTickGet(VOID) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CyclePerTickGet(VOID)
{ {
return g_sysClock / KERNEL_TICK_PER_SECOND; return g_sysClock / KERNEL_TICK_PER_SECOND;
} }
//LOS_GetCpuCycle函数：获取CPU周期数
LITE_OS_SEC_TEXT_MINOR VOID LOS_GetCpuCycle(UINT32 *highCnt, UINT32 *lowCnt) LITE_OS_SEC_TEXT_MINOR VOID LOS_GetCpuCycle(UINT32 *highCnt, UINT32 *lowCnt)
{ {
UINT64 cycle; UINT64 cycle;
@ -130,7 +129,7 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_GetCpuCycle(UINT32 *highCnt, UINT32 *lowCnt)
/* get the low 32 bits */ /* get the low 32 bits */
*lowCnt = (UINT32)(cycle & 0xFFFFFFFFULL); *lowCnt = (UINT32)(cycle & 0xFFFFFFFFULL);
} }
//LOS_CurrNanosec函数：获取当前的纳秒数
LITE_OS_SEC_TEXT_MINOR UINT64 LOS_CurrNanosec(VOID) LITE_OS_SEC_TEXT_MINOR UINT64 LOS_CurrNanosec(VOID)
{ {
UINT64 nanos; UINT64 nanos;
@ -138,7 +137,7 @@ LITE_OS_SEC_TEXT_MINOR UINT64 LOS_CurrNanosec(VOID)
nanos = HalClockGetCycles() * (OS_SYS_NS_PER_SECOND / OS_SYS_NS_PER_MS) / (g_sysClock / OS_SYS_NS_PER_MS); nanos = HalClockGetCycles() * (OS_SYS_NS_PER_SECOND / OS_SYS_NS_PER_MS) / (g_sysClock / OS_SYS_NS_PER_MS);
return nanos; return nanos;
} }
//LOS_MS2Tick函数：将毫秒转换为tick数
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MS2Tick(UINT32 millisec) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MS2Tick(UINT32 millisec)
{ {
UINT64 delaySec; UINT64 delaySec;
@ -150,17 +149,17 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MS2Tick(UINT32 millisec)
delaySec = (UINT64)millisec * KERNEL_TICK_PER_SECOND; delaySec = (UINT64)millisec * KERNEL_TICK_PER_SECOND;
return (UINT32)((delaySec + OS_SYS_MS_PER_SECOND - 1) / OS_SYS_MS_PER_SECOND); return (UINT32)((delaySec + OS_SYS_MS_PER_SECOND - 1) / OS_SYS_MS_PER_SECOND);
} }
//LOS_Tick2MS函数：将tick数转换为毫秒数
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_Tick2MS(UINT32 tick) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_Tick2MS(UINT32 tick)
{ {
return (UINT32)(((UINT64)tick * OS_SYS_MS_PER_SECOND) / KERNEL_TICK_PER_SECOND); return (UINT32)(((UINT64)tick * OS_SYS_MS_PER_SECOND) / KERNEL_TICK_PER_SECOND);
} }
//LOS_Udelay函数：微秒级延迟函数
LITE_OS_SEC_TEXT_MINOR VOID LOS_Udelay(UINT32 usecs) LITE_OS_SEC_TEXT_MINOR VOID LOS_Udelay(UINT32 usecs)
{ {
HalDelayUs(usecs); HalDelayUs(usecs);
} }
//LOS_Mdelay函数：毫秒级延迟函数
LITE_OS_SEC_TEXT_MINOR VOID LOS_Mdelay(UINT32 msecs) LITE_OS_SEC_TEXT_MINOR VOID LOS_Mdelay(UINT32 msecs)
{ {
UINT32 delayUs = (UINT32_MAX / OS_SYS_US_PER_MS) * OS_SYS_US_PER_MS; UINT32 delayUs = (UINT32_MAX / OS_SYS_US_PER_MS) * OS_SYS_US_PER_MS;

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

@ -43,9 +43,9 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
#define HEAP_CAST(t, exp) ((t)(exp))//这个宏定义是一个类型转换的快捷方式。它接受两个参数，t 表示目标类型，exp 是需要进行类型转换的表达式。这个宏最终会将 exp 转换为类型 t。 #define HEAP_CAST(t, exp) ((t)(exp))
#define HEAP_ALIGN sizeof(UINTPTR)//这个宏定义定义了 HEAP_ALIGN，它的值是 sizeof(UINTPTR)。sizeof 操作符用于返回其操作数的大小（以字节为单位），所以 HEAP_ALIGN 的值将取决于 UINTPTR 类型的大小。 #define HEAP_ALIGN sizeof(UINTPTR)
#define MALLOC_MAXSIZE (0xFFFFFFFF - HEAP_ALIGN + 1)//这个宏定义了 MALLOC_MAXSIZE，它的值是 0xFFFFFFFF - HEAP_ALIGN + 1。在这里，0xFFFFFFFF 表示一个32位无符号整数的最大值，HEAP_ALIGN 已经在上面定义过了。这个宏定义似乎是用来表示在分配内存时可能的最大尺寸。 #define MALLOC_MAXSIZE (0xFFFFFFFF - HEAP_ALIGN + 1)
/* /*
* Description : look up the next memory node according to one memory node in the memory block list. * Description : look up the next memory node according to one memory node in the memory block list.
@ -53,25 +53,13 @@ extern "C" {
* struct LosHeapNode *node --- Size of memory in bytes to allocate * struct LosHeapNode *node --- Size of memory in bytes to allocate
* Return : Pointer to next memory node * 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) struct LosHeapNode* OsHeapPrvGetNext(struct LosHeapManager *heapMan, struct LosHeapNode *node)
{ {
return (heapMan->tail == node) ? NULL : (struct LosHeapNode *)(UINTPTR)(node->data + node->size); return (heapMan->tail == node) ? NULL : (struct LosHeapNode *)(UINTPTR)(node->data + node->size);
} }
#ifdef LOSCFG_MEM_TASK_STAT #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 OsHeapStatInit(struct LosHeapManager *heapMan, UINT32 size)
{ {
(VOID)memset_s(&heapMan->stat, sizeof(Memstat), 0, sizeof(Memstat)); (VOID)memset_s(&heapMan->stat, sizeof(Memstat), 0, sizeof(Memstat));
@ -79,16 +67,7 @@ VOID OsHeapStatInit(struct LosHeapManager *heapMan, UINT32 size)
heapMan->stat.memTotalUsed = sizeof(struct LosHeapNode) + sizeof(struct LosHeapManager); heapMan->stat.memTotalUsed = sizeof(struct LosHeapNode) + sizeof(struct LosHeapManager);
heapMan->stat.memTotalPeak = heapMan->stat.memTotalUsed; 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) VOID OsHeapStatAddUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
{ {
UINT32 taskId; UINT32 taskId;
@ -108,13 +87,7 @@ VOID OsHeapStatAddUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
node->taskId = taskId; node->taskId = taskId;
OS_MEM_ADD_USED(&heapMan->stat, blockSize, 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) VOID OsHeapStatDecUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
{ {
UINT32 taskId = node->taskId; UINT32 taskId = node->taskId;
@ -124,25 +97,17 @@ VOID OsHeapStatDecUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node)
} }
#else /* LOSCFG_MEM_TASK_STAT */ #else /* LOSCFG_MEM_TASK_STAT */
//函数用于初始化堆管理器的内存统计信息。它接受两个参数：heapMan 表示堆管理器的指针，size 表示堆的总大小。在这个备选实现中，该函数没有任何具体的实现操作，直接返回。
VOID OsHeapStatInit(struct LosHeapManager *heapMan, UINT32 size) { } VOID OsHeapStatInit(struct LosHeapManager *heapMan, UINT32 size) { }
//函数用于向堆的统计信息中添加被使用的内存块。它接受两个参数：heapMan 表示堆管理器的指针，node 表示要添加到统计信息中的堆节点指针。在这个备选实现中，该函数没有任何具体的实现操作，什么也不做。
VOID OsHeapStatAddUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node) { } VOID OsHeapStatAddUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node) { }
//函数用于从堆的统计信息中减少被使用的内存块。它接受两个参数：heapMan 表示堆管理器的指针，node 表示要从统计信息中减少使用的堆节点指针。在这个备选实现中，该函数没有任何具体的实现操作，什么也不做。
VOID OsHeapStatDecUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node) { } VOID OsHeapStatDecUsed(struct LosHeapManager *heapMan, struct LosHeapNode *node) { }
#endif /* LOSCFG_MEM_TASK_STAT */ #endif /* LOSCFG_MEM_TASK_STAT */
#ifdef LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK #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) UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
{ {
struct LosHeapNode *node = (struct LosHeapNode *)(heap + 1); struct LosHeapNode *node = (struct LosHeapNode *)(heap + 1);
@ -162,7 +127,7 @@ UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
} }
#else /* LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK */ #else /* LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK */
//这段代码实现了一个名为 OsHeapIntegrityCheck 的函数，它接受一个指向 LosHeapManager 结构体的指针作为参数，并直接返回 LOS_OK。
UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap) UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
{ {
return LOS_OK; return LOS_OK;
@ -171,16 +136,12 @@ UINT32 OsHeapIntegrityCheck(struct LosHeapManager *heap)
#endif /* LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK */ #endif /* LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK */
#ifdef LOSCFG_KERNEL_MEM_SLAB_EXTENTION #ifdef LOSCFG_KERNEL_MEM_SLAB_EXTENTION
/*接受一个指向内存池的指针 pool 和一个表示需要分配内存大小的参数 size。
在函数内部，调用 OsHeapAlloc 函数将内存分配操作委托给堆内存管理器进行处理。
最终将堆内存管理器返回的内存分配结果直接返回给调用者。*/
VOID *OsMemAlloc(VOID *pool, UINT32 size) VOID *OsMemAlloc(VOID *pool, UINT32 size)
{ {
return OsHeapAlloc(pool, size); return OsHeapAlloc(pool, size);
} }
/*接受一个指向内存池的指针 pool 和一个指向待释放内存块的指针 ptr。
在函数内部，调用 OsHeapFree 函数将内存释放操作委托给堆内存管理器进行处理。
检查堆内存管理器的释放操作是否成功，如果成功则返回 LOS_OK 表示释放成功，否则返回 LOS_NOK 表示释放失败。*/
UINT32 OsMemFree(VOID *pool, const VOID *ptr) UINT32 OsMemFree(VOID *pool, const VOID *ptr)
{ {
if (OsHeapFree(pool, ptr) == TRUE) { if (OsHeapFree(pool, ptr) == TRUE) {
@ -199,19 +160,6 @@ UINT32 OsMemFree(VOID *pool, const VOID *ptr)
* UITN32 size --- size of the heap memory pool * UITN32 size --- size of the heap memory pool
* Return : 1:success 0:error * 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) BOOL OsHeapInit(VOID *pool, UINT32 size)
{ {
struct LosHeapNode *node = NULL; struct LosHeapNode *node = NULL;
@ -244,33 +192,6 @@ BOOL OsHeapInit(VOID *pool, UINT32 size)
* UINT32 size --- size of the heap memory pool * UINT32 size --- size of the heap memory pool
* Return : NULL:error, other value:the address of the memory we alloced * 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) VOID *OsHeapAlloc(VOID *pool, UINT32 size)
{ {
struct LosHeapNode *node = NULL; struct LosHeapNode *node = NULL;
@ -301,18 +222,11 @@ VOID *OsHeapAlloc(VOID *pool, UINT32 size)
} }
/* alloc failed */ /* alloc failed */
/*这是一个条件判断语句，如果找到的最佳节点为空（即没有足够大小的空闲节点），则执行花括号中的代码块。*/
if (best == NULL) { if (best == NULL) {
PRINT_ERR("there's not enough mem to alloc 0x%x Bytes!\n", alignSize);//在没有足够空闲内存来分配请求大小的内存块时，打印错误信息，提示用户无法分配指定大小的内存。 PRINT_ERR("there's not enough mem to alloc 0x%x Bytes!\n", alignSize);
goto OUT;//跳转到标签 OUT 处，这通常是用于执行清理和释放资源的操作。 goto 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)) { if ((best->size - alignSize) > sizeof(struct LosHeapNode)) {
/* hole divide into 2 */ /* hole divide into 2 */
node = (struct LosHeapNode*)(UINTPTR)(best->data + alignSize); node = (struct LosHeapNode*)(UINTPTR)(best->data + alignSize);
@ -332,11 +246,7 @@ node->prev = best;
best->size = alignSize; best->size = alignSize;
} }
/*这段代码可能是用于实现动态内存分配器的代码。具体来说，函数名称 SIZE_MATCH 可能代表了一种内存分配策略，即在进行内存分配时，选择最能够匹配请求大小的空闲内存块进行分配。
其中，代码中的 best 变量可能表示了符合请求大小的、最佳匹配的空闲内存块。代码将 best 的 align 属性设为 0，used 属性设为 1，表示该内存块已被使用。然后，代码通过指针 ptr 返回了该内存块的起始地址。最后，代码调用了 OsHeapStatAddUsed 函数，可能是用于统计内存分配情况的函数，将该内存块的使用信息记录到内存分配器的统计数据中。
值得注意的是，代码中可能存在一些未给出的上下文信息，因此具体含义可能需要根据上下文和相关代码进行推断和理解。*/
SIZE_MATCH: SIZE_MATCH:
best->align = 0; best->align = 0;
best->used = 1; best->used = 1;
@ -354,15 +264,6 @@ OUT:
* UINT32 boundary --- boundary the heap needs align * UINT32 boundary --- boundary the heap needs align
* Return : NULL:error, other value:the address of the memory we alloced * 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) VOID* OsHeapAllocAlign(VOID *pool, UINT32 size, UINT32 boundary)
{ {
UINT32 useSize; UINT32 useSize;
@ -396,15 +297,7 @@ VOID* OsHeapAllocAlign(VOID *pool, UINT32 size, UINT32 boundary)
OUT: OUT:
return ptr; 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) STATIC VOID OsHeapDoFree(struct LosHeapManager *heapMan, struct LosHeapNode *curNode)
{ {
struct LosHeapNode *node = curNode; struct LosHeapNode *node = curNode;
@ -437,15 +330,6 @@ STATIC VOID OsHeapDoFree(struct LosHeapManager *heapMan, struct LosHeapNode *cur
* VOID* ptr --- the pointer of heap memory we want to free * VOID* ptr --- the pointer of heap memory we want to free
* Return : 1:success 0:error * 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) BOOL OsHeapFree(VOID *pool, const VOID *ptr)
{ {
struct LosHeapNode *node = NULL; struct LosHeapNode *node = NULL;
@ -494,19 +378,6 @@ OUT:
* Output : status --- heap statistics * Output : status --- heap statistics
* Return : LOS_OK on success or error code on failure * 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 OsHeapStatisticsGet(VOID *pool, LosHeapStatus *status)
{ {
UINT32 heapUsed = 0; UINT32 heapUsed = 0;
@ -564,15 +435,6 @@ UINT32 OsHeapStatisticsGet(VOID *pool, LosHeapStatus *status)
* Input : pool --- Pointer to the manager, to distinguish heap * Input : pool --- Pointer to the manager, to distinguish heap
* Return : max free block size * 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 OsHeapGetMaxFreeBlkSize(VOID *pool)
{ {
UINT32 size = 0; UINT32 size = 0;

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

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

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

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

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

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

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

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

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

37
src/kernel/base/shellcmd/hwi_shellcmd.c
Unescape View File

@ -25,11 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
这个文件是针对LiteOS操作系统中的Shell命令编写的，主要实现了对硬件中断信息的获取和显示功能，
包括了对硬件中断的共享模式、响应次数、CPU利用率等信息的获取和显示。根据操作系统配置不同，
还包括了对CPU利用率的不同时间段（所有时间、最近10秒、最近1秒）的统计和显示。
*/
#include "los_config.h" #include "los_config.h"
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
#ifdef LOSCFG_CPUP_INCLUDE_IRQ #ifdef LOSCFG_CPUP_INCLUDE_IRQ
@ -43,7 +39,7 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//这个函数实现了打印硬件中断信息的表头
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdHwiInfoTitle(VOID) LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdHwiInfoTitle(VOID)
{ {
#ifdef LOSCFG_CPUP_INCLUDE_IRQ #ifdef LOSCFG_CPUP_INCLUDE_IRQ
@ -57,7 +53,7 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdHwiInfoTitle(VOID)
PRINTK("----------- ----- ------------- --------- --------\n"); PRINTK("----------- ----- ------------- --------- --------\n");
#endif #endif
} }
//这个函数会根据传入的硬件中断句柄信息，获取该中断是否为共享模式
STATIC BOOL GetHwiShare(const HwiHandleInfo *hwiForm) STATIC BOOL GetHwiShare(const HwiHandleInfo *hwiForm)
{ {
#ifndef LOSCFG_SHARED_IRQ #ifndef LOSCFG_SHARED_IRQ
@ -68,10 +64,9 @@ STATIC BOOL GetHwiShare(const HwiHandleInfo *hwiForm)
} }
#ifdef LOSCFG_CPUP_INCLUDE_IRQ #ifdef LOSCFG_CPUP_INCLUDE_IRQ
STATIC CPUP_INFO_S g_hwiCpupAll[LOSCFG_PLATFORM_HWI_LIMIT];//所有时间段CPU利用率的统计信息 STATIC CPUP_INFO_S g_hwiCpupAll[LOSCFG_PLATFORM_HWI_LIMIT];
STATIC CPUP_INFO_S g_hwiCpup10s[LOSCFG_PLATFORM_HWI_LIMIT];//最近10sCPU利用率的统计信息 STATIC CPUP_INFO_S g_hwiCpup10s[LOSCFG_PLATFORM_HWI_LIMIT];
STATIC CPUP_INFO_S g_hwiCpup1s[LOSCFG_PLATFORM_HWI_LIMIT];//最近1sCPU利用率的统计信息 STATIC CPUP_INFO_S g_hwiCpup1s[LOSCFG_PLATFORM_HWI_LIMIT];
//这个函数实现了硬件中断信息的查询，根据参数argc和argv判断是否有误，并调用其他函数获取硬件中断的各项信息，最终打印输出硬件中断的详细信息。
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
{ {
UINT32 i, intSave; UINT32 i, intSave;
@ -80,24 +75,22 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
HwiHandleInfo *hwiForm = NULL; HwiHandleInfo *hwiForm = NULL;
(VOID)argv; (VOID)argv;
//打印错误信息
if (argc > 0) { if (argc > 0) {
PRINTK("\nUsage: hwi\n"); PRINTK("\nUsage: hwi\n");
return OS_ERROR; return OS_ERROR;
} }
(VOID)memset_s(g_hwiCpupAll, size, 0, size);//置零 (VOID)memset_s(g_hwiCpupAll, size, 0, size);
(VOID)memset_s(g_hwiCpup10s, size, 0, size);//置零 (VOID)memset_s(g_hwiCpup10s, size, 0, size);
(VOID)memset_s(g_hwiCpup1s, size, 0, size);//置零 (VOID)memset_s(g_hwiCpup1s, size, 0, size);
intSave = LOS_IntLock(); intSave = LOS_IntLock();
(VOID)LOS_AllCpuUsage(LOSCFG_PLATFORM_HWI_LIMIT, g_hwiCpupAll, CPUP_ALL_TIME, 0); (VOID)LOS_AllCpuUsage(LOSCFG_PLATFORM_HWI_LIMIT, g_hwiCpupAll, CPUP_ALL_TIME, 0);
(VOID)LOS_AllCpuUsage(LOSCFG_PLATFORM_HWI_LIMIT, g_hwiCpup10s, CPUP_LAST_TEN_SECONDS, 0); (VOID)LOS_AllCpuUsage(LOSCFG_PLATFORM_HWI_LIMIT, g_hwiCpup10s, CPUP_LAST_TEN_SECONDS, 0);
(VOID)LOS_AllCpuUsage(LOSCFG_PLATFORM_HWI_LIMIT, g_hwiCpup1s, CPUP_LAST_ONE_SECONDS, 0); (VOID)LOS_AllCpuUsage(LOSCFG_PLATFORM_HWI_LIMIT, g_hwiCpup1s, CPUP_LAST_ONE_SECONDS, 0);
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
//打印硬件中断信息的表头
OsShellCmdHwiInfoTitle(); OsShellCmdHwiInfoTitle();
//打印CPU硬件中断的利用率
for (i = 0; i < LOSCFG_PLATFORM_HWI_LIMIT; i++) { for (i = 0; i < LOSCFG_PLATFORM_HWI_LIMIT; i++) {
if (!HWI_IS_REGISTED(i)) { if (!HWI_IS_REGISTED(i)) {
continue; continue;
@ -108,7 +101,6 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
} }
/* Different cores has different hwi form implementation */ /* Different cores has different hwi form implementation */
//打印各个时间内的硬件中断利用率
hwiForm = OsGetHwiForm(i); hwiForm = OsGetHwiForm(i);
PRINTK("%-8u\t %-s\t %-10u\t %-10llu %2u.%-7u %2u.%-7u %2u.%-6u", PRINTK("%-8u\t %-s\t %-10u\t %-10llu %2u.%-7u %2u.%-7u %2u.%-6u",
i, GetHwiShare(hwiForm) ? "Y" : "N", OsGetHwiFormCnt(i), cycles, i, GetHwiShare(hwiForm) ? "Y" : "N", OsGetHwiFormCnt(i), cycles,
@ -118,7 +110,6 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
#ifdef LOSCFG_SHARED_IRQ #ifdef LOSCFG_SHARED_IRQ
hwiForm = hwiForm->next; hwiForm = hwiForm->next;
#endif #endif
//打印中断设备ID和信息
if ((hwiForm->registerInfo != 0) && ((HWI_IRQ_PARAM_S *)hwiForm->registerInfo)->pName != NULL) { if ((hwiForm->registerInfo != 0) && ((HWI_IRQ_PARAM_S *)hwiForm->registerInfo)->pName != NULL) {
PRINTK("\t %-16s 0x%-.8x\n", PRINTK("\t %-16s 0x%-.8x\n",
((HWI_IRQ_PARAM_S *)hwiForm->registerInfo)->pName, ((HWI_IRQ_PARAM_S *)hwiForm->registerInfo)->pName,
@ -137,28 +128,24 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
return 0; return 0;
} }
#else #else
//这个函数主要实现对hwi命令的解释功能，输出硬件中断信息
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
{ {
UINT32 i; UINT32 i;
HwiHandleInfo *hwiForm = NULL; HwiHandleInfo *hwiForm = NULL;
//参数错误，打印错误信息
(VOID)argv; (VOID)argv;
if (argc > 0) { if (argc > 0) {
PRINTK("\nUsage: hwi\n"); PRINTK("\nUsage: hwi\n");
return OS_ERROR; return OS_ERROR;
} }
//打印硬件中断信息的表头
OsShellCmdHwiInfoTitle(); OsShellCmdHwiInfoTitle();
//遍历所有硬件中断寄存器
for (i = 0; i < LOSCFG_PLATFORM_HWI_LIMIT; i++) { for (i = 0; i < LOSCFG_PLATFORM_HWI_LIMIT; i++) {
if (!HWI_IS_REGISTED(i)) { if (!HWI_IS_REGISTED(i)) {
continue; continue;
} }
/* Different cores has different hwi form implementation */ /* Different cores has different hwi form implementation */
//输出信息
hwiForm = OsGetHwiForm(i); hwiForm = OsGetHwiForm(i);
PRINTK("%-8u\t %-s\t %-10u", i, GetHwiShare(hwiForm) ? "Y" : "N", OsGetHwiFormCnt(i)); PRINTK("%-8u\t %-s\t %-10u", i, GetHwiShare(hwiForm) ? "Y" : "N", OsGetHwiFormCnt(i));
#ifdef LOSCFG_SHARED_IRQ #ifdef LOSCFG_SHARED_IRQ
@ -183,7 +170,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
return 0; return 0;
} }
#endif #endif
//该函数实现了OsShellCmdHwi的函数调用，用户可以输入hwi命令来调用该函数，从而查询和展示硬件中断信息
SHELLCMD_ENTRY(hwi_shellcmd, CMD_TYPE_EX, "hwi", 0, (CmdCallBackFunc)OsShellCmdHwi); SHELLCMD_ENTRY(hwi_shellcmd, CMD_TYPE_EX, "hwi", 0, (CmdCallBackFunc)OsShellCmdHwi);
#ifdef __cplusplus #ifdef __cplusplus

64
src/kernel/base/shellcmd/mempt_shellcmd.c
Unescape View File

@ -25,10 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
这个文件是针对LiteOS操作系统中的Shell命令编写的，
主要实现了系统内存的安全检查、系统内存使用情况的显示、读取指定内存中指定位置指定长度的信息和释放内存空间。
*/
#include "stdlib.h" #include "stdlib.h"
#include "stdio.h" #include "stdio.h"
#include "los_memory_pri.h" #include "los_memory_pri.h"
@ -48,60 +45,54 @@ extern "C" {
#define MEM_SIZE_1K 0x400 #define MEM_SIZE_1K 0x400
#define MEM_SIZE_1M 0x100000 #define MEM_SIZE_1M 0x100000
//这个函数用于检查内存完整性
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMemCheck(INT32 argc, const CHAR *argv[]) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMemCheck(INT32 argc, const CHAR *argv[])
{ {
//打印错误信息
if (argc > 0) { if (argc > 0) {
PRINTK("\nUsage: memcheck\n"); PRINTK("\nUsage: memcheck\n");
return OS_ERROR; return OS_ERROR;
} }
//调用OsMemIntegrityMultiCheck函数完成内存完整性检查
OsMemIntegrityMultiCheck(); OsMemIntegrityMultiCheck();
return 0; return 0;
} }
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
//这个函数可以读取内存中指定位置指定长度的数据，调用OsDumpMemByte函数完成内存读取并打印数据
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMemRead(INT32 argc, const CHAR *argv[]) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMemRead(INT32 argc, const CHAR *argv[])
{ {
size_t tempAddr; size_t tempAddr;
size_t length; size_t length;
CHAR *ptrlen = NULL; CHAR *ptrlen = NULL;
CHAR *ptrAddr = NULL; CHAR *ptrAddr = NULL;
//读取错误，打印错误信息
if ((argc == 0) || (argc > 2)) { /* argc is num of parameters */ if ((argc == 0) || (argc > 2)) { /* argc is num of parameters */
PRINTK("\nUsage: readreg [ADDRESS] [LENGTH]\n"); PRINTK("\nUsage: readreg [ADDRESS] [LENGTH]\n");
return OS_ERROR; return OS_ERROR;
} }
//读取正确
if (argc == 1) { if (argc == 1) {
length = 0; length = 0;
} else { } else {
//读取长度为负数，打印错误信息
length = strtoul(argv[1], &ptrlen, 0); length = strtoul(argv[1], &ptrlen, 0);
if ((ptrlen == NULL) || (*ptrlen != 0)) { if ((ptrlen == NULL) || (*ptrlen != 0)) {
PRINTK("readreg invalid length %s\n", argv[1]); PRINTK("readreg invalid length %s\n", argv[1]);
return OS_ERROR; return OS_ERROR;
} }
} }
//保存ptrAddr的地址
tempAddr = strtoul(argv[0], &ptrAddr, 0); tempAddr = strtoul(argv[0], &ptrAddr, 0);
//地址错误，打印错误信息
if ((ptrAddr == NULL) || (*ptrAddr != 0) || (tempAddr > g_sys_mem_addr_end) || if ((ptrAddr == NULL) || (*ptrAddr != 0) || (tempAddr > g_sys_mem_addr_end) ||
((tempAddr + length) > g_sys_mem_addr_end) || (tempAddr > (OS_NULL_INT - length))) { ((tempAddr + length) > g_sys_mem_addr_end) || (tempAddr > (OS_NULL_INT - length))) {
PRINTK("readreg invalid address %s\n", argv[0]); PRINTK("readreg invalid address %s\n", argv[0]);
return OS_ERROR; return OS_ERROR;
} }
//调用OsDumpMemByte函数，打印指定内存位置读取的信息。
OsDumpMemByte(length, tempAddr); OsDumpMemByte(length, tempAddr);
return 0; return 0;
} }
//这个函数用于输出代码段、数据段、只读数据段和BSS段的大小信息。
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdSectionInfo(INT32 argc, const CHAR *argv[]) LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdSectionInfo(INT32 argc, const CHAR *argv[])
{ {
//计算各部分长度
size_t textLen = &__text_end - &__text_start; size_t textLen = &__text_end - &__text_start;
size_t dataLen = &__ram_data_end - &__ram_data_start; size_t dataLen = &__ram_data_end - &__ram_data_start;
size_t rodataLen = &__rodata_end - &__rodata_start; size_t rodataLen = &__rodata_end - &__rodata_start;
@ -112,7 +103,7 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdSectionInfo(INT32 argc, const CHAR
dataLen += &__fast_data_end - &__fast_data_start; dataLen += &__fast_data_end - &__fast_data_start;
rodataLen += &__fast_rodata_end - &__fast_rodata_start; rodataLen += &__fast_rodata_end - &__fast_rodata_start;
#endif #endif
//打印代码段、数据段、只读数据段、BSS段的大小信息
PRINTK("\r\n text data rodata bss\n"); PRINTK("\r\n text data rodata bss\n");
if ((argc == 1) && (strcmp(argv[0], "-k") == 0)) { if ((argc == 1) && (strcmp(argv[0], "-k") == 0)) {
PRINTK("Mem: %-9lu %-10lu %-10lu %-10lu\n", textLen / MEM_SIZE_1K, dataLen / MEM_SIZE_1K, PRINTK("Mem: %-9lu %-10lu %-10lu %-10lu\n", textLen / MEM_SIZE_1K, dataLen / MEM_SIZE_1K,
@ -124,24 +115,19 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdSectionInfo(INT32 argc, const CHAR
PRINTK("Mem: %-9lu %-10lu %-10lu %-10lu\n", textLen, dataLen, rodataLen, bssLen); PRINTK("Mem: %-9lu %-10lu %-10lu %-10lu\n", textLen, dataLen, rodataLen, bssLen);
} }
} }
//这个函数用于输出系统可用的内存总量、已经使用的内存量和剩余内存量的大小
LITE_OS_SEC_TEXT_MINOR STATIC UINT32 OsShellCmdFreeInfo(INT32 argc, const CHAR *argv[]) LITE_OS_SEC_TEXT_MINOR STATIC UINT32 OsShellCmdFreeInfo(INT32 argc, const CHAR *argv[])
{ {
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
//调用LOS_MemTotaUsedGet函数得到已经使用的内存量
UINT32 memUsed0 = LOS_MemTotalUsedGet(m_aucSysMem0); UINT32 memUsed0 = LOS_MemTotalUsedGet(m_aucSysMem0);
//调用LOS_MemPoolSizeGet函数得到系统可用的内存总量
UINT32 totalMem0 = LOS_MemPoolSizeGet(m_aucSysMem0); UINT32 totalMem0 = LOS_MemPoolSizeGet(m_aucSysMem0);
//计算得到系统剩余的内存量
UINT32 freeMem0 = totalMem0 - memUsed0; UINT32 freeMem0 = totalMem0 - memUsed0;
#endif #endif
//调用LOS_MemTotaUsedGet函数得到已经使用的内存量
UINT32 memUsed = LOS_MemTotalUsedGet(m_aucSysMem1); UINT32 memUsed = LOS_MemTotalUsedGet(m_aucSysMem1);
//调用LOS_MemPoolSizeGet函数得到系统可用的内存总量
UINT32 totalMem = LOS_MemPoolSizeGet(m_aucSysMem1); UINT32 totalMem = LOS_MemPoolSizeGet(m_aucSysMem1);
/计算得到系统剩余的内存量
UINT32 freeMem = totalMem - memUsed; UINT32 freeMem = totalMem - memUsed;
//打印统可用的内存总量、已经使用的内存量和剩余内存量的大小
if ((argc == 0) || if ((argc == 0) ||
((argc == 1) && (strcmp(argv[0], "-k") == 0)) || ((argc == 1) && (strcmp(argv[0], "-k") == 0)) ||
((argc == 1) && (strcmp(argv[0], "-m") == 0))) { ((argc == 1) && (strcmp(argv[0], "-m") == 0))) {
@ -171,57 +157,47 @@ LITE_OS_SEC_TEXT_MINOR STATIC UINT32 OsShellCmdFreeInfo(INT32 argc, const CHAR *
PRINTK("Mem1: %-9u %-10u %-10u\n", totalMem0, memUsed0, freeMem0); PRINTK("Mem1: %-9u %-10u %-10u\n", totalMem0, memUsed0, freeMem0);
#endif #endif
} else { } else {
//打印错误信息
PRINTK("\nUsage: free or free [-k/-m]\n"); PRINTK("\nUsage: free or free [-k/-m]\n");
return OS_ERROR; return OS_ERROR;
} }
return 0; return 0;
} }
//这个函数用于显示系统内存的使用情况，调用了OsShellCmdFreeInfo和OsShellCmdSectionInfo函数完成内存使用情况和内存分配情况的打印输出。
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdFree(INT32 argc, const CHAR *argv[]) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdFree(INT32 argc, const CHAR *argv[])
{ {
//打印错误信息
if (argc > 1) { if (argc > 1) {
PRINTK("\nUsage: free or free [-k/-m]\n"); PRINTK("\nUsage: free or free [-k/-m]\n");
return OS_ERROR; return OS_ERROR;
} }
//打印错误信息
if (OsShellCmdFreeInfo(argc, argv) != 0) { if (OsShellCmdFreeInfo(argc, argv) != 0) {
return OS_ERROR; return OS_ERROR;
} }
//调用OsShellCmdSectionInfo函数输出存使用情况和内存分配情况
OsShellCmdSectionInfo(argc, argv); OsShellCmdSectionInfo(argc, argv);
return 0; return 0;
} }
//这个函数根据参数选择输出不同的系统信息，在控制台上输出相应的信息。
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdUname(INT32 argc, const CHAR *argv[]) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdUname(INT32 argc, const CHAR *argv[])
{ {
//如果参数为0，在控制台上打印Huawei LiteOS
if (argc == 0) { if (argc == 0) {
PRINTK("Huawei LiteOS\n"); PRINTK("Huawei LiteOS\n");
return 0; return 0;
} }
if (argc == 1) { if (argc == 1) {
//系统参数为-a时，打印LiteOS所有的信息
if (strcmp(argv[0], "-a") == 0) { if (strcmp(argv[0], "-a") == 0) {
PRINTK("%s %s %s %s %s\n", HW_LITEOS_VER, HW_LITEOS_SYSNAME, HW_LITEOS_KERNEL_VERSION_STRING, PRINTK("%s %s %s %s %s\n", HW_LITEOS_VER, HW_LITEOS_SYSNAME, HW_LITEOS_KERNEL_VERSION_STRING,
__DATE__, __TIME__); __DATE__, __TIME__);
return 0; return 0;
//系统参数为-s时，打印Huawei LiteOS
} else if (strcmp(argv[0], "-s") == 0) { } else if (strcmp(argv[0], "-s") == 0) {
PRINTK("Huawei LiteOS\n"); PRINTK("Huawei LiteOS\n");
return 0; return 0;
//系统参数为-t时，打印系统创建的时间信息
} else if (strcmp(argv[0], "-t") == 0) { } else if (strcmp(argv[0], "-t") == 0) {
PRINTK("build date : %s %s", __DATE__, __TIME__); PRINTK("build date : %s %s", __DATE__, __TIME__);
return 0; return 0;
//系统参数为-v时，打印LiteOS的版本信息和时间信息
} else if (strcmp(argv[0], "-v") == 0) { } else if (strcmp(argv[0], "-v") == 0) {
PRINTK("%s %s %s %s\n", HW_LITEOS_SYSNAME, HW_LITEOS_KERNEL_VERSION_STRING, PRINTK("%s %s %s %s\n", HW_LITEOS_SYSNAME, HW_LITEOS_KERNEL_VERSION_STRING,
__DATE__, __TIME__); __DATE__, __TIME__);
return 0; return 0;
//系统参数为--help时，打印各参数的含义
} else if (strcmp(argv[0], "--help") == 0) { } else if (strcmp(argv[0], "--help") == 0) {
PRINTK("-a, print all information\n" PRINTK("-a, print all information\n"
"-s, print the kernel name\n" "-s, print the kernel name\n"
@ -230,22 +206,20 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdUname(INT32 argc, const CHAR *argv[])
return 0; return 0;
} }
} }
//如果都不是，打印错误信息，提示用户输入--help来查看信息
PRINTK("uname: invalid option %s\n" PRINTK("uname: invalid option %s\n"
"Try 'uname --help' for more information.\n", "Try 'uname --help' for more information.\n",
argv[0]); argv[0]);
return OS_ERROR; return OS_ERROR;
} }
#ifdef LOSCFG_MEM_LEAKCHECK #ifdef LOSCFG_MEM_LEAKCHECK
//这个函数打印了系统已使用的内存信息
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMemUsed(INT32 argc, const CHAR *argv[]) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMemUsed(INT32 argc, const CHAR *argv[])
{ {
//打印错误信息
if (argc > 0) { if (argc > 0) {
PRINTK("\nUsage: memused\n"); PRINTK("\nUsage: memused\n");
return OS_ERROR; return OS_ERROR;
} }
//调用OsMemUsedNodeShow函数，输出已使用的节点信息
OsMemUsedNodeShow(m_aucSysMem1); OsMemUsedNodeShow(m_aucSysMem1);
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
@ -256,14 +230,6 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdMemUsed(INT32 argc, const CHAR *argv[])
} }
#endif #endif
/*
命令解释器个各个命令调用的函数以及作用
memcheck命令：检查内存完整性。调用了OsMemIntegrityMultiCheck函数完成内存完整性检查。
memread [ADDRESS] [LENGTH]命令：读取指定地址和长度的内存数据。调用了OsDumpMemByte函数完成内存数据读取并打印输出。
free命令：显示系统内存的使用情况。调用了OsShellCmdFreeInfo和OsShellCmdSectionInfo函数完成内存使用情况和内存分配情况的打印输出。
uname [-a/-s/-t/-v]命令：显示系统信息。根据参数选择输出不同的系统信息。调用了PRINTK宏在控制台上输出相应的信息。
*/
#ifdef LOSCFG_MEM_LEAKCHECK #ifdef LOSCFG_MEM_LEAKCHECK
SHELLCMD_ENTRY(memused_shellcmd, CMD_TYPE_EX, "memused", 0, (CmdCallBackFunc)OsShellCmdMemUsed); SHELLCMD_ENTRY(memused_shellcmd, CMD_TYPE_EX, "memused", 0, (CmdCallBackFunc)OsShellCmdMemUsed);
#endif #endif

29
src/kernel/base/shellcmd/stack_shellcmd.c
Unescape View File

@ -25,10 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
这段文件是针对LiteOS操作系统中的Shell命令编写的，
主要实现了内核异常处理机制中与堆栈相关的功能，包括堆栈信息的获取和检查。
*/
#include "securec.h" #include "securec.h"
#include "los_config.h" #include "los_config.h"
#include "los_stackinfo_pri.h" #include "los_stackinfo_pri.h"
@ -37,7 +34,7 @@
#include "shcmd.h" #include "shcmd.h"
#include "shell.h" #include "shell.h"
#endif #endif
//这个函数用于检查堆栈是否溢出
VOID OsExcStackCheck(VOID) VOID OsExcStackCheck(VOID)
{ {
UINT32 index; UINT32 index;
@ -45,17 +42,15 @@ VOID OsExcStackCheck(VOID)
UINTPTR *stackTop = NULL; UINTPTR *stackTop = NULL;
const StackInfo *stackInfo = NULL; const StackInfo *stackInfo = NULL;
UINT32 stackNum; UINT32 stackNum;
//获取堆栈信息，如果堆栈信息错误，直接返回
OsGetStackInfo(&stackInfo, &stackNum); OsGetStackInfo(&stackInfo, &stackNum);
if ((stackInfo == NULL) || (stackNum == 0)) { if ((stackInfo == NULL) || (stackNum == 0)) {
return; return;
} }
//从头开始，遍历所有的堆栈
for (index = 0; index < stackNum; index++) { for (index = 0; index < stackNum; index++) {
for (cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) { for (cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) {
//堆栈的栈顶
stackTop = (UINTPTR *)((UINTPTR)stackInfo[index].stackTop + cpuid * stackInfo[index].stackSize); stackTop = (UINTPTR *)((UINTPTR)stackInfo[index].stackTop + cpuid * stackInfo[index].stackSize);
//检查栈顶信息是否被篡改，如果被篡改输出该堆栈溢出的信息
if (*stackTop != OS_STACK_MAGIC_WORD) { if (*stackTop != OS_STACK_MAGIC_WORD) {
PRINT_ERR("cpu:%u %s overflow , magic word changed to 0x%x\n", PRINT_ERR("cpu:%u %s overflow , magic word changed to 0x%x\n",
LOSCFG_KERNEL_CORE_NUM - 1 - cpuid, stackInfo[index].stackName, *stackTop); LOSCFG_KERNEL_CORE_NUM - 1 - cpuid, stackInfo[index].stackName, *stackTop);
@ -63,7 +58,7 @@ VOID OsExcStackCheck(VOID)
} }
} }
} }
//这个函数用于获取并打印所有的堆栈信息
VOID OsExcStackInfo(VOID) VOID OsExcStackInfo(VOID)
{ {
UINT32 index; UINT32 index;
@ -73,31 +68,29 @@ VOID OsExcStackInfo(VOID)
UINTPTR *stack = NULL; UINTPTR *stack = NULL;
const StackInfo *stackInfo = NULL; const StackInfo *stackInfo = NULL;
UINT32 stackNum; UINT32 stackNum;
//获取堆栈信息，如果堆栈信息错误，直接返回
OsGetStackInfo(&stackInfo, &stackNum); OsGetStackInfo(&stackInfo, &stackNum);
if ((stackInfo == NULL) || (stackNum == 0)) { if ((stackInfo == NULL) || (stackNum == 0)) {
return; return;
} }
//输出堆栈名、CPU ID、堆栈的地址、堆栈的总大小，堆栈已使用的大小
PrintExcInfo("\n stack name cpu id stack addr total size used size\n" PrintExcInfo("\n stack name cpu id stack addr total size used size\n"
" ---------- ------ --------- -------- --------\n"); " ---------- ------ --------- -------- --------\n");
//从头开始，遍历所有的堆栈
for (index = 0; index < stackNum; index++) { for (index = 0; index < stackNum; index++) {
for (cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) { for (cpuid = 0; cpuid < LOSCFG_KERNEL_CORE_NUM; cpuid++) {
//获取堆栈的栈顶
stackTop = (UINTPTR *)((UINTPTR)stackInfo[index].stackTop + cpuid * stackInfo[index].stackSize); stackTop = (UINTPTR *)((UINTPTR)stackInfo[index].stackTop + cpuid * stackInfo[index].stackSize);
stack = (UINTPTR *)((UINTPTR)stackTop + stackInfo[index].stackSize); stack = (UINTPTR *)((UINTPTR)stackTop + stackInfo[index].stackSize);
//调用OsStackWaterLineGet函数计算堆栈已使用的大小
(VOID)OsStackWaterLineGet(stack, stackTop, &size); (VOID)OsStackWaterLineGet(stack, stackTop, &size);
//输出各类信息
PrintExcInfo("%11s %-5d %-10p 0x%-8x 0x%-4x\n", stackInfo[index].stackName, PrintExcInfo("%11s %-5d %-10p 0x%-8x 0x%-4x\n", stackInfo[index].stackName,
LOSCFG_KERNEL_CORE_NUM - 1 - cpuid, stackTop, stackInfo[index].stackSize, size); LOSCFG_KERNEL_CORE_NUM - 1 - cpuid, stackTop, stackInfo[index].stackSize, size);
} }
} }
//进行堆栈溢出检查
OsExcStackCheck(); OsExcStackCheck();
} }
//注册Shell命令stack，调用OsExcStackInfo函数获取并打印所有堆栈信息至控制台。
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
SHELLCMD_ENTRY(stack_shellcmd, CMD_TYPE_EX, "stack", 1, (CmdCallBackFunc)OsExcStackInfo); SHELLCMD_ENTRY(stack_shellcmd, CMD_TYPE_EX, "stack", 1, (CmdCallBackFunc)OsExcStackInfo);
#endif #endif

41
src/kernel/base/shellcmd/swtmr_shellcmd.c
Unescape View File

@ -25,10 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
这个文件主要是针对LiteOS系统中软件定时器的命令行操作进行定义和实现的，
主要实现了根据软件定时器的ID输出软件定时器的各种信息。
*/
#include "los_config.h" #include "los_config.h"
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
#include "stdlib.h" #include "stdlib.h"
@ -45,20 +42,20 @@ extern "C" {
#define SWTMR_STRLEN 12 #define SWTMR_STRLEN 12
#ifdef LOSCFG_BASE_CORE_SWTMR #ifdef LOSCFG_BASE_CORE_SWTMR
//展示g_shellSwtmrMode的数据
LITE_OS_SEC_DATA_MINOR STATIC CHAR g_shellSwtmrMode[][SWTMR_STRLEN] = { LITE_OS_SEC_DATA_MINOR STATIC CHAR g_shellSwtmrMode[][SWTMR_STRLEN] = {
"Once", "Once",
"Period", "Period",
"NSD", "NSD",
"OPP", "OPP",
}; };
//展示g_shellSwtmrStatus的数据
LITE_OS_SEC_DATA_MINOR STATIC CHAR g_shellSwtmrStatus[][SWTMR_STRLEN] = { LITE_OS_SEC_DATA_MINOR STATIC CHAR g_shellSwtmrStatus[][SWTMR_STRLEN] = {
"UnUsed", "UnUsed",
"Created", "Created",
"Ticking", "Ticking",
}; };
//这个函数用于打印软件定时器的信息，包括定时器ID、状态、模式、间隔、参数和处理函数地址等。
STATIC VOID OsPrintSwtmrMsg(const LosSwtmrCB *swtmr) STATIC VOID OsPrintSwtmrMsg(const LosSwtmrCB *swtmr)
{ {
PRINTK("0x%08x " PRINTK("0x%08x "
@ -67,20 +64,20 @@ STATIC VOID OsPrintSwtmrMsg(const LosSwtmrCB *swtmr)
"%-6u " "%-6u "
"0x%08x " "0x%08x "
"%p\n", "%p\n",
swtmr->timerId % LOSCFG_BASE_CORE_SWTMR_LIMIT,//打印定时器ID swtmr->timerId % LOSCFG_BASE_CORE_SWTMR_LIMIT,
g_shellSwtmrStatus[swtmr->state],//打印定时器的状态 g_shellSwtmrStatus[swtmr->state],
g_shellSwtmrMode[swtmr->mode],//打印定时器的模式 g_shellSwtmrMode[swtmr->mode],
swtmr->interval,//打印定时器的间隔 swtmr->interval,
swtmr->arg,//打印定时器的参数 swtmr->arg,
swtmr->handler);//打印定时器的处理函数地址 swtmr->handler);
} }
//这个函数用于打印软件定时器信息的表头
STATIC INLINE VOID OsPrintSwtmrMsgHead(VOID) STATIC INLINE VOID OsPrintSwtmrMsgHead(VOID)
{ {
PRINTK("\r\nSwTmrID State Mode Interval Arg handlerAddr\n"); PRINTK("\r\nSwTmrID State Mode Interval Arg handlerAddr\n");
PRINTK("---------- ------- ------- --------- ---------- --------\n"); PRINTK("---------- ------- ------- --------- ---------- --------\n");
} }
//这个函数用于获取软件定时器的信息。
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const UINT8 **argv) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const UINT8 **argv)
{ {
#define OS_ALL_SWTMR_MASK 0xffffffff #define OS_ALL_SWTMR_MASK 0xffffffff
@ -90,36 +87,34 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const UINT8 **a
size_t timerId; size_t timerId;
UINT16 num = 0; UINT16 num = 0;
CHAR *endPtr = NULL; CHAR *endPtr = NULL;
//打印错误信息
if (argc > 1) { if (argc > 1) {
PRINTK("\nUsage: swtmr [ID]\n"); PRINTK("\nUsage: swtmr [ID]\n");
return OS_ERROR; return OS_ERROR;
} }
//获取计时器ID
if (argc == 0) { if (argc == 0) {
timerId = OS_ALL_SWTMR_MASK; timerId = OS_ALL_SWTMR_MASK;
} else { } else {
//没有这个ID，打印错误信息
timerId = strtoul((CHAR *)argv[0], &endPtr, 0); timerId = strtoul((CHAR *)argv[0], &endPtr, 0);
if ((endPtr == NULL) || (*endPtr != 0) || (timerId > LOSCFG_BASE_CORE_SWTMR_LIMIT)) { if ((endPtr == NULL) || (*endPtr != 0) || (timerId > LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
PRINTK("\nswtmr ID can't access %s.\n", argv[0]); PRINTK("\nswtmr ID can't access %s.\n", argv[0]);
return OS_ERROR; return OS_ERROR;
} }
} }
//遍历所有计时器，让计时器的状态加1
for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr1++) { for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr1++) {
if (swtmr1->state == 0) { if (swtmr1->state == 0) {
num = num + 1; num = num + 1;
} }
} }
//达到时间限制，输出错误信息
if (num == LOSCFG_BASE_CORE_SWTMR_LIMIT) { if (num == LOSCFG_BASE_CORE_SWTMR_LIMIT) {
PRINTK("\r\nThere is no swtmr was created!\n"); PRINTK("\r\nThere is no swtmr was created!\n");
return OS_ERROR; return OS_ERROR;
} }
//打印软件定时器信息的表头
OsPrintSwtmrMsgHead(); OsPrintSwtmrMsgHead();
//打印软件定时器的各类信息
if (timerId == OS_ALL_SWTMR_MASK) { if (timerId == OS_ALL_SWTMR_MASK) {
for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) { for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) {
if (swtmr->state != 0) { if (swtmr->state != 0) {
@ -137,7 +132,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const UINT8 **a
} }
return LOS_OK; return LOS_OK;
} }
//注册Shell命令swtmr，调用OsShellCmdSwtmrInfoGet函数获取软件定时器的信息。根据输入的参数获取特定或者所有软件定时器的状态信息并打印出来。
SHELLCMD_ENTRY(swtmr_shellcmd, CMD_TYPE_EX, "swtmr", 1, (CmdCallBackFunc)OsShellCmdSwtmrInfoGet); SHELLCMD_ENTRY(swtmr_shellcmd, CMD_TYPE_EX, "swtmr", 1, (CmdCallBackFunc)OsShellCmdSwtmrInfoGet);
#endif #endif

54
src/kernel/base/shellcmd/sysinfo_shellcmd.c
Unescape View File

@ -25,10 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
这段文件是针对LiteOS操作系统中的Shell命令编写的，
主要实现了获取系统信息的功能，获取的信息包括进程数量、信号量数量、互斥锁数量、消息队列数量和软件定时器数量。
*/
#include "los_config.h" #include "los_config.h"
#include "los_swtmr.h" #include "los_swtmr.h"
#include "los_sem_pri.h" #include "los_sem_pri.h"
@ -46,173 +43,141 @@
extern "C" { extern "C" {
#endif #endif
#endif /* __cplusplus */ #endif /* __cplusplus */
//这个函数用于获取当系统的进程数量
UINT32 OsShellCmdTaskCntGet(VOID) UINT32 OsShellCmdTaskCntGet(VOID)
{ {
UINT32 loop; UINT32 loop;
UINT32 taskCnt = 0; UINT32 taskCnt = 0;
UINT32 intSave; UINT32 intSave;
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
//加上锁，用于防止中断
intSave = LOS_IntLock(); intSave = LOS_IntLock();
//遍历所有进程，并统计进程数量
for (loop = 0; loop < g_taskMaxNum; loop++) { for (loop = 0; loop < g_taskMaxNum; loop++) {
taskCB = (LosTaskCB *)g_taskCBArray + loop; taskCB = (LosTaskCB *)g_taskCBArray + loop;
//若该进程未使用，则直接跳过
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) { if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
continue; continue;
} }
taskCnt++; taskCnt++;
} }
//为进程解锁
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
//返回系统的进程数量
return taskCnt; return taskCnt;
} }
#ifdef LOSCFG_BASE_IPC_SEM #ifdef LOSCFG_BASE_IPC_SEM
//这个函数用于获取当前系统信号量的数量
UINT32 OsShellCmdSemCntGet(VOID) UINT32 OsShellCmdSemCntGet(VOID)
{ {
UINT32 loop; UINT32 loop;
UINT32 semCnt = 0; UINT32 semCnt = 0;
UINT32 intSave; UINT32 intSave;
LosSemCB *semNode = NULL; LosSemCB *semNode = NULL;
//加上锁，用于防止中断
intSave = LOS_IntLock(); intSave = LOS_IntLock();
//遍历所有信号量
for (loop = 0; loop < LOSCFG_BASE_IPC_SEM_LIMIT; loop++) { for (loop = 0; loop < LOSCFG_BASE_IPC_SEM_LIMIT; loop++) {
semNode = GET_SEM(loop); semNode = GET_SEM(loop);
//如果该信号量被使用了，数量加1
if (semNode->semStat == LOS_USED) { if (semNode->semStat == LOS_USED) {
semCnt++; semCnt++;
} }
} }
//为进程解锁
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
//返回系统信号量的数量
return semCnt; return semCnt;
} }
#endif #endif
#ifdef LOSCFG_BASE_IPC_MUX #ifdef LOSCFG_BASE_IPC_MUX
//这个函数用于获取当前系统互斥锁的数量
UINT32 OsShellCmdMuxCntGet(VOID) UINT32 OsShellCmdMuxCntGet(VOID)
{ {
UINT32 loop; UINT32 loop;
UINT32 muxCnt = 0; UINT32 muxCnt = 0;
UINT32 intSave; UINT32 intSave;
LosMuxCB *muxNode = NULL; LosMuxCB *muxNode = NULL;
//加上锁，用于防止中断
intSave = LOS_IntLock(); intSave = LOS_IntLock();
//遍历所有互斥锁
for (loop = 0; loop < LOSCFG_BASE_IPC_MUX_LIMIT; loop++) { for (loop = 0; loop < LOSCFG_BASE_IPC_MUX_LIMIT; loop++) {
muxNode = GET_MUX(loop); muxNode = GET_MUX(loop);
//如果互斥锁的状态被使用了，数量加1
if (muxNode->muxStat == LOS_USED) { if (muxNode->muxStat == LOS_USED) {
muxCnt++; muxCnt++;
} }
} }
//为进程解锁
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
//返回系统互斥锁的数量
return muxCnt; return muxCnt;
} }
#endif #endif
#ifdef LOSCFG_BASE_IPC_QUEUE #ifdef LOSCFG_BASE_IPC_QUEUE
//这个函数用于获取系统消息队列的数量
UINT32 OsShellCmdQueueCntGet(VOID) UINT32 OsShellCmdQueueCntGet(VOID)
{ {
UINT32 loop; UINT32 loop;
UINT32 queueCnt = 0; UINT32 queueCnt = 0;
UINT32 intSave; UINT32 intSave;
LosQueueCB *queueCB = NULL; LosQueueCB *queueCB = NULL;
//加上锁，用于防止中断
intSave = LOS_IntLock(); intSave = LOS_IntLock();
queueCB = g_allQueue; queueCB = g_allQueue;
//遍历所有消息队列
for (loop = 0; loop < LOSCFG_BASE_IPC_QUEUE_LIMIT; loop++, queueCB++) { for (loop = 0; loop < LOSCFG_BASE_IPC_QUEUE_LIMIT; loop++, queueCB++) {
//如果消息队列的状态为使用，数量加1
if (queueCB->queueState == LOS_USED) { if (queueCB->queueState == LOS_USED) {
queueCnt++; queueCnt++;
} }
} }
//为进程解锁
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
//返回系统获取消息队列的数量
return queueCnt; return queueCnt;
} }
#endif #endif
#ifdef LOSCFG_BASE_CORE_SWTMR #ifdef LOSCFG_BASE_CORE_SWTMR
//这个函数用于获取系统软件定时器的数量
UINT32 OsShellCmdSwtmrCntGet(VOID) UINT32 OsShellCmdSwtmrCntGet(VOID)
{ {
UINT32 loop; UINT32 loop;
UINT32 swtmrCnt = 0; UINT32 swtmrCnt = 0;
UINT32 intSave; UINT32 intSave;
LosSwtmrCB *swtmrCB = NULL; LosSwtmrCB *swtmrCB = NULL;
//加上锁，用于防止中断
intSave = LOS_IntLock(); intSave = LOS_IntLock();
swtmrCB = g_swtmrCBArray; swtmrCB = g_swtmrCBArray;
//遍历所有软件定时器
for (loop = 0; loop < LOSCFG_BASE_CORE_SWTMR_LIMIT; loop++, swtmrCB++) { for (loop = 0; loop < LOSCFG_BASE_CORE_SWTMR_LIMIT; loop++, swtmrCB++) {
//如果软件定时器的状态不是没有使用，数量加1
if (swtmrCB->state != OS_SWTMR_STATUS_UNUSED) { if (swtmrCB->state != OS_SWTMR_STATUS_UNUSED) {
swtmrCnt++; swtmrCnt++;
} }
} }
//为进程解锁
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
//返回系统软件定时器的数量
return swtmrCnt; return swtmrCnt;
} }
#endif #endif
//这个函数用于打印系统信息，包括进程数量、信号量数量、互斥锁数量、消息队列数量和软件定时器数量。
LITE_OS_SEC_TEXT_MINOR VOID OsShellCmdSystemInfoGet(VOID) LITE_OS_SEC_TEXT_MINOR VOID OsShellCmdSystemInfoGet(VOID)
{ {
//打印表头
PRINTK("\n Module Used Total\n"); PRINTK("\n Module Used Total\n");
PRINTK("--------------------------------\n"); PRINTK("--------------------------------\n");
//打印进程数量
PRINTK(" Task %-10u%-10d\n", PRINTK(" Task %-10u%-10d\n",
OsShellCmdTaskCntGet(), OsShellCmdTaskCntGet(),
LOSCFG_BASE_CORE_TSK_LIMIT); LOSCFG_BASE_CORE_TSK_LIMIT);
#ifdef LOSCFG_BASE_IPC_SEM #ifdef LOSCFG_BASE_IPC_SEM
//打印信号量数量
PRINTK(" Sem %-10u%-10d\n", PRINTK(" Sem %-10u%-10d\n",
OsShellCmdSemCntGet(), OsShellCmdSemCntGet(),
LOSCFG_BASE_IPC_SEM_LIMIT); LOSCFG_BASE_IPC_SEM_LIMIT);
#endif #endif
#ifdef LOSCFG_BASE_IPC_MUX #ifdef LOSCFG_BASE_IPC_MUX
//打印互斥锁数量
PRINTK(" Mutex %-10u%-10d\n", PRINTK(" Mutex %-10u%-10d\n",
OsShellCmdMuxCntGet(), OsShellCmdMuxCntGet(),
LOSCFG_BASE_IPC_MUX_LIMIT); LOSCFG_BASE_IPC_MUX_LIMIT);
#endif #endif
#ifdef LOSCFG_BASE_IPC_QUEUE #ifdef LOSCFG_BASE_IPC_QUEUE
//打印消息队列数量
PRINTK(" Queue %-10u%-10d\n", PRINTK(" Queue %-10u%-10d\n",
OsShellCmdQueueCntGet(), OsShellCmdQueueCntGet(),
LOSCFG_BASE_IPC_QUEUE_LIMIT); LOSCFG_BASE_IPC_QUEUE_LIMIT);
#endif #endif
#ifdef LOSCFG_BASE_CORE_SWTMR #ifdef LOSCFG_BASE_CORE_SWTMR
//打印软件定时器数量
PRINTK(" SwTmr %-10u%-10d\n", PRINTK(" SwTmr %-10u%-10d\n",
OsShellCmdSwtmrCntGet(), OsShellCmdSwtmrCntGet(),
LOSCFG_BASE_CORE_SWTMR_LIMIT); LOSCFG_BASE_CORE_SWTMR_LIMIT);
#endif #endif
} }
//这个函数用于处理shell的systeminfo命令，根据相应的参数，做出相应的处理
INT32 OsShellCmdSystemInfo(INT32 argc, const CHAR **argv) INT32 OsShellCmdSystemInfo(INT32 argc, const CHAR **argv)
{ {
//如果参数数量为0，调用OsShellCmdSystemInfoGet函数，打印所有的系统信息。
if (argc == 0) { if (argc == 0) {
OsShellCmdSystemInfoGet(); OsShellCmdSystemInfoGet();
return 0; return 0;
} }
//参数数量不正确，打印错误信息
PRINTK("systeminfo: invalid option %s\n" PRINTK("systeminfo: invalid option %s\n"
"Systeminfo has NO ARGS.\n", "Systeminfo has NO ARGS.\n",
argv[0]); argv[0]);
@ -220,7 +185,6 @@ INT32 OsShellCmdSystemInfo(INT32 argc, const CHAR **argv)
} }
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
//注册Shell命令systeminfo，调用OsShellCmdSystemInfo，根据参数输出当前系统的进程数量、信号量数量、互斥锁数量、消息队列数量和软件定时器数量。。
SHELLCMD_ENTRY(systeminfo_shellcmd, CMD_TYPE_EX, "systeminfo", 1, (CmdCallBackFunc)OsShellCmdSystemInfo); SHELLCMD_ENTRY(systeminfo_shellcmd, CMD_TYPE_EX, "systeminfo", 1, (CmdCallBackFunc)OsShellCmdSystemInfo);
#endif /* LOSCFG_SHELL */ #endif /* LOSCFG_SHELL */

112
src/kernel/base/shellcmd/task_shellcmd.c
Unescape View File

@ -25,10 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
这段文件是针对LiteOS操作系统中的Shell命令编写的，
主要实现了操作系统的任务管理模块，通过进程号获取该进程的所有信息，或者直接获取所有进程的信息。
*/
#include "stdio.h" #include "stdio.h"
#include "stdlib.h" #include "stdlib.h"
#include "los_config.h" #include "los_config.h"
@ -56,65 +53,55 @@ extern "C" {
#define OS_INVALID_SEM_ID 0xFFFFFFFF #define OS_INVALID_SEM_ID 0xFFFFFFFF
#ifdef LOSCFG_KERNEL_CPUP #ifdef LOSCFG_KERNEL_CPUP
LITE_OS_SEC_BSS STATIC CPUP_INFO_S g_taskCpupAll[LOSCFG_BASE_CORE_TSK_LIMIT];//所有时间段CPU利用率的统计信息 LITE_OS_SEC_BSS STATIC CPUP_INFO_S g_taskCpupAll[LOSCFG_BASE_CORE_TSK_LIMIT];
LITE_OS_SEC_BSS STATIC CPUP_INFO_S g_taskCpup10s[LOSCFG_BASE_CORE_TSK_LIMIT];//最近10sCPU利用率的统计信息 LITE_OS_SEC_BSS STATIC CPUP_INFO_S g_taskCpup10s[LOSCFG_BASE_CORE_TSK_LIMIT];
LITE_OS_SEC_BSS STATIC CPUP_INFO_S g_taskCpup1s[LOSCFG_BASE_CORE_TSK_LIMIT];//最近1sCPU利用率的统计信息 LITE_OS_SEC_BSS STATIC CPUP_INFO_S g_taskCpup1s[LOSCFG_BASE_CORE_TSK_LIMIT];
#endif #endif
LITE_OS_SEC_BSS STATIC UINT32 g_taskWaterLine[LOSCFG_BASE_CORE_TSK_LIMIT];//记录各个堆栈最低的水位 LITE_OS_SEC_BSS STATIC UINT32 g_taskWaterLine[LOSCFG_BASE_CORE_TSK_LIMIT];
//这个函数通过进程状态位来判断进程的状态，并返回相应的字符串表示进程状态。
LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdConvertTskStatus(UINT16 taskStatus) LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdConvertTskStatus(UINT16 taskStatus)
{ {
//进程处于运行状态，返回Running
if (taskStatus & OS_TASK_STATUS_RUNNING) { if (taskStatus & OS_TASK_STATUS_RUNNING) {
return (UINT8 *)"Running"; return (UINT8 *)"Running";
//进程处于就绪状态，返回Ready
} else if (taskStatus & OS_TASK_STATUS_READY) { } else if (taskStatus & OS_TASK_STATUS_READY) {
return (UINT8 *)"Ready"; return (UINT8 *)"Ready";
//其他的进程状态
} else { } else {
//进程处于延迟状态，返回Delay
if (taskStatus & OS_TASK_STATUS_DELAY) { if (taskStatus & OS_TASK_STATUS_DELAY) {
return (UINT8 *)"Delay"; return (UINT8 *)"Delay";
} else if (taskStatus & OS_TASK_STATUS_PEND_TIME) { } else if (taskStatus & OS_TASK_STATUS_PEND_TIME) {
//进程处于定时挂起状态，返回SuspendTime
if (taskStatus & OS_TASK_STATUS_SUSPEND) { if (taskStatus & OS_TASK_STATUS_SUSPEND) {
return (UINT8 *)"SuspendTime"; return (UINT8 *)"SuspendTime";
//进程处于定时等待状态，返回PendTime
} else if (taskStatus & OS_TASK_STATUS_PEND) { } else if (taskStatus & OS_TASK_STATUS_PEND) {
return (UINT8 *)"PendTime"; return (UINT8 *)"PendTime";
} }
//进程处于等待状态，返回Pend
} else if (taskStatus & OS_TASK_STATUS_PEND) { } else if (taskStatus & OS_TASK_STATUS_PEND) {
return (UINT8 *)"Pend"; return (UINT8 *)"Pend";
//进程处于挂起状态，返回SusPend
} else if (taskStatus & OS_TASK_STATUS_SUSPEND) { } else if (taskStatus & OS_TASK_STATUS_SUSPEND) {
return (UINT8 *)"Suspend"; return (UINT8 *)"Suspend";
} }
} }
//进程状态不合法，返回Invalid
return (UINT8 *)"Invalid"; return (UINT8 *)"Invalid";
} }
//这个函数用于获取所有堆栈的栈水位（堆栈的使用情况）
STATIC VOID OsShellCmdTaskWaterLineGet(const LosTaskCB *allTaskArray) STATIC VOID OsShellCmdTaskWaterLineGet(const LosTaskCB *allTaskArray)
{ {
const LosTaskCB *taskCB = NULL; const LosTaskCB *taskCB = NULL;
UINT32 loop; UINT32 loop;
//遍历所有堆栈
for (loop = 0; loop < g_taskMaxNum; ++loop) { for (loop = 0; loop < g_taskMaxNum; ++loop) {
taskCB = allTaskArray + loop; taskCB = allTaskArray + loop;
//如果该堆栈未使用，直接跳过
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) { if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
continue; continue;
} }
//调用OsStackWaterLineGet，输出堆栈的栈水位信息
(VOID)OsStackWaterLineGet((const UINTPTR *)((UINTPTR)taskCB->topOfStack + taskCB->stackSize), (VOID)OsStackWaterLineGet((const UINTPTR *)((UINTPTR)taskCB->topOfStack + taskCB->stackSize),
(const UINTPTR *)taskCB->topOfStack, &g_taskWaterLine[taskCB->taskId]); (const UINTPTR *)taskCB->topOfStack, &g_taskWaterLine[taskCB->taskId]);
} }
} }
#ifdef LOSCFG_SHELL_EXCINFO_DUMP #ifdef LOSCFG_SHELL_EXCINFO_DUMP
//这个函数用于在异常信息输出缓冲区中打印任务信息的标题。
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoTitleExc(VOID) LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoTitleExc(VOID)
{ {
WriteExcInfoToBuf("\r\nName TaskEntryAddr TID "); WriteExcInfoToBuf("\r\nName TaskEntryAddr TID ");
@ -146,7 +133,7 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoTitleExc(VOID)
WriteExcInfoToBuf("\n"); WriteExcInfoToBuf("\n");
} }
#endif #endif
//这个函数用于在控制台打印任务信息的标题。
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoTitle(VOID) LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoTitle(VOID)
{ {
PRINTK("\r\nName TaskEntryAddr TID "); PRINTK("\r\nName TaskEntryAddr TID ");
@ -178,15 +165,14 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoTitle(VOID)
PRINTK("\n"); PRINTK("\n");
#ifdef LOSCFG_SHELL_EXCINFO_DUMP #ifdef LOSCFG_SHELL_EXCINFO_DUMP
//在异常信息输出缓冲区中打印任务信息的标题。
OsShellCmdTskInfoTitleExc(); OsShellCmdTskInfoTitleExc();
#endif #endif
} }
//这个函数通过TCB（进程控制块）获取进程所持有的信号量的ID。
LITE_OS_SEC_TEXT_MINOR STATIC INLINE UINT32 OsGetSemID(const LosTaskCB *taskCB) LITE_OS_SEC_TEXT_MINOR STATIC INLINE UINT32 OsGetSemID(const LosTaskCB *taskCB)
{ {
UINT32 semId = OS_INVALID_SEM_ID; UINT32 semId = OS_INVALID_SEM_ID;
//返回该进程的信号量ID
if (taskCB->taskSem != NULL) { if (taskCB->taskSem != NULL) {
semId = ((LosSemCB *)taskCB->taskSem)->semId; semId = ((LosSemCB *)taskCB->taskSem)->semId;
} }
@ -195,13 +181,12 @@ LITE_OS_SEC_TEXT_MINOR STATIC INLINE UINT32 OsGetSemID(const LosTaskCB *taskCB)
} }
#ifdef LOSCFG_SHELL_EXCINFO_DUMP #ifdef LOSCFG_SHELL_EXCINFO_DUMP
//这个函数用于将TCB（进程控制块）中的进程信息输出到异常信息输出缓冲区。
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoDataExc(const LosTaskCB *allTaskArray) LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoDataExc(const LosTaskCB *allTaskArray)
{ {
const LosTaskCB *taskCB = NULL; const LosTaskCB *taskCB = NULL;
UINT32 loop; UINT32 loop;
UINT32 semId; UINT32 semId;
//遍历所有的堆栈
for (loop = 0; loop < g_taskMaxNum; ++loop) { for (loop = 0; loop < g_taskMaxNum; ++loop) {
taskCB = allTaskArray + loop; taskCB = allTaskArray + loop;
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) { if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
@ -209,25 +194,21 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoDataExc(const LosTaskCB *all
} }
semId = OsGetSemID(taskCB); semId = OsGetSemID(taskCB);
//调用WriteExcInfoToBuf函数，将TCB（进程控制块）的信息写入缓冲区
WriteExcInfoToBuf("%-23s0x%-18.8x0x%-5x", taskCB->taskName, taskCB->taskEntry, taskCB->taskId); WriteExcInfoToBuf("%-23s0x%-18.8x0x%-5x", taskCB->taskName, taskCB->taskEntry, taskCB->taskId);
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
//调用WriteExcInfoToBuf函数，将TCB（进程控制块）的信息写入缓冲区
WriteExcInfoToBuf("0x%04x %4d ", taskCB->cpuAffiMask, (INT16)(taskCB->currCpu)); WriteExcInfoToBuf("0x%04x %4d ", taskCB->cpuAffiMask, (INT16)(taskCB->currCpu));
#endif #endif
//调用WriteExcInfoToBuf函数，将TCB（进程控制块）的信息写入缓冲区
WriteExcInfoToBuf("%-11u%-13s0x%-11x0x%-11x 0x%-.8x 0x%-.8x 0x%-11x", taskCB->priority, WriteExcInfoToBuf("%-11u%-13s0x%-11x0x%-11x 0x%-.8x 0x%-.8x 0x%-11x", taskCB->priority,
OsShellCmdConvertTskStatus(taskCB->taskStatus), taskCB->stackSize, OsShellCmdConvertTskStatus(taskCB->taskStatus), taskCB->stackSize,
g_taskWaterLine[taskCB->taskId], g_taskWaterLine[taskCB->taskId],
taskCB->stackPointer, taskCB->topOfStack, semId); taskCB->stackPointer, taskCB->topOfStack, semId);
#ifdef LOSCFG_BASE_IPC_EVENT #ifdef LOSCFG_BASE_IPC_EVENT
//调用WriteExcInfoToBuf函数，将TCB（进程控制块）的信息写入缓冲区
WriteExcInfoToBuf("0x%-6x", taskCB->eventMask); WriteExcInfoToBuf("0x%-6x", taskCB->eventMask);
#endif #endif
#ifdef LOSCFG_KERNEL_CPUP #ifdef LOSCFG_KERNEL_CPUP
//调用WriteExcInfoToBuf函数，将TCB（进程控制块）的信息写入缓冲区
WriteExcInfoToBuf(" %4u.%1u%9u.%1u%8u.%1u ", WriteExcInfoToBuf(" %4u.%1u%9u.%1u%8u.%1u ",
g_taskCpupAll[taskCB->taskId].uwUsage / LOS_CPUP_PRECISION_MULT, g_taskCpupAll[taskCB->taskId].uwUsage / LOS_CPUP_PRECISION_MULT,
g_taskCpupAll[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT, g_taskCpupAll[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT,
@ -237,47 +218,41 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoDataExc(const LosTaskCB *all
g_taskCpup1s[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT); g_taskCpup1s[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT);
#endif /* LOSCFG_KERNEL_CPUP */ #endif /* LOSCFG_KERNEL_CPUP */
#ifdef LOSCFG_MEM_TASK_STAT #ifdef LOSCFG_MEM_TASK_STAT
//调用WriteExcInfoToBuf函数，将TCB（进程控制块）的信息写入缓冲区
WriteExcInfoToBuf(" %-11u", OsMemTaskUsage(taskCB->taskId)); WriteExcInfoToBuf(" %-11u", OsMemTaskUsage(taskCB->taskId));
#endif #endif
//调用WriteExcInfoToBuf函数，将TCB（进程控制块）的信息写入缓冲区
WriteExcInfoToBuf("\n"); WriteExcInfoToBuf("\n");
} }
} }
#endif #endif
//这个函数可以将TCB(进程控制块)中的信息输出到控制台。
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoData(const LosTaskCB *allTaskArray) LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoData(const LosTaskCB *allTaskArray)
{ {
const LosTaskCB *taskCB = NULL; const LosTaskCB *taskCB = NULL;
UINT32 loop; UINT32 loop;
UINT32 semId; UINT32 semId;
//遍历所有的堆栈
for (loop = 0; loop < g_taskMaxNum; ++loop) { for (loop = 0; loop < g_taskMaxNum; ++loop) {
taskCB = allTaskArray + loop; taskCB = allTaskArray + loop;
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) { if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
continue; continue;
} }
//调用OsGetSemID获取该进程的信号量ID
semId = OsGetSemID(taskCB); semId = OsGetSemID(taskCB);
//输出进程信息到控制台
PRINTK("%-23s0x%-18.8x0x%-5x", taskCB->taskName, taskCB->taskEntry, taskCB->taskId); PRINTK("%-23s0x%-18.8x0x%-5x", taskCB->taskName, taskCB->taskEntry, taskCB->taskId);
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
//输出进程信息到控制台
PRINTK("0x%04x %4d ", taskCB->cpuAffiMask, (INT16)(taskCB->currCpu)); PRINTK("0x%04x %4d ", taskCB->cpuAffiMask, (INT16)(taskCB->currCpu));
#endif #endif
//输出进程信息到控制台
PRINTK("%-11u%-13s0x%-11x0x%-11x 0x%-.8x 0x%-.8x 0x%-11x", taskCB->priority, PRINTK("%-11u%-13s0x%-11x0x%-11x 0x%-.8x 0x%-.8x 0x%-11x", taskCB->priority,
OsShellCmdConvertTskStatus(taskCB->taskStatus), taskCB->stackSize, OsShellCmdConvertTskStatus(taskCB->taskStatus), taskCB->stackSize,
g_taskWaterLine[taskCB->taskId], g_taskWaterLine[taskCB->taskId],
taskCB->stackPointer, taskCB->topOfStack, semId); taskCB->stackPointer, taskCB->topOfStack, semId);
#ifdef LOSCFG_BASE_IPC_EVENT #ifdef LOSCFG_BASE_IPC_EVENT
//输出进程信息到控制台
PRINTK("0x%-6x", taskCB->eventMask); PRINTK("0x%-6x", taskCB->eventMask);
#endif #endif
#ifdef LOSCFG_KERNEL_CPUP #ifdef LOSCFG_KERNEL_CPUP
//输出进程信息到控制台
PRINTK(" %4u.%1u%9u.%1u%8u.%1u ", PRINTK(" %4u.%1u%9u.%1u%8u.%1u ",
g_taskCpupAll[taskCB->taskId].uwUsage / LOS_CPUP_PRECISION_MULT, g_taskCpupAll[taskCB->taskId].uwUsage / LOS_CPUP_PRECISION_MULT,
g_taskCpupAll[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT, g_taskCpupAll[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT,
@ -287,19 +262,16 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsShellCmdTskInfoData(const LosTaskCB *allTas
g_taskCpup1s[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT); g_taskCpup1s[taskCB->taskId].uwUsage % LOS_CPUP_PRECISION_MULT);
#endif /* LOSCFG_KERNEL_CPUP */ #endif /* LOSCFG_KERNEL_CPUP */
#ifdef LOSCFG_MEM_TASK_STAT #ifdef LOSCFG_MEM_TASK_STAT
//输出进程信息到控制台
PRINTK(" %-11u", OsMemTaskUsage(taskCB->taskId)); PRINTK(" %-11u", OsMemTaskUsage(taskCB->taskId));
#endif #endif
//输出进程信息到控制台
PRINTK("\n"); PRINTK("\n");
} }
#ifdef LOSCFG_SHELL_EXCINFO_DUMP #ifdef LOSCFG_SHELL_EXCINFO_DUMP
//将进程信息输出到异常信息输出缓冲区。
OsShellCmdTskInfoDataExc(allTaskArray); OsShellCmdTskInfoDataExc(allTaskArray);
#endif #endif
} }
//这个函数可以通过进程号获取进程的信息
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskId) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskId)
{ {
BOOL backupFlag = TRUE; BOOL backupFlag = TRUE;
@ -307,57 +279,50 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskId)
UINT32 size, intSave; UINT32 size, intSave;
LosTaskCB *tcbArray = NULL; LosTaskCB *tcbArray = NULL;
INT32 ret; INT32 ret;
//如果是目标进程
if (taskId == OS_ALL_TASK_MASK) { if (taskId == OS_ALL_TASK_MASK) {
size = g_taskMaxNum * sizeof(LosTaskCB); size = g_taskMaxNum * sizeof(LosTaskCB);
tcbArray = (LosTaskCB *)LOS_MemAlloc(m_aucSysMem1, size); tcbArray = (LosTaskCB *)LOS_MemAlloc(m_aucSysMem1, size);
//如果目标进程信息为空，输出错误信息，将backup设置为Fasle，不备份该进程信息
if (tcbArray == NULL) { if (tcbArray == NULL) {
PRINTK("Memory is not enough to save task info!\n"); PRINTK("Memory is not enough to save task info!\n");
tcbArray = g_taskCBArray; tcbArray = g_taskCBArray;
backupFlag = FALSE; backupFlag = FALSE;
} }
#ifdef LOSCFG_KERNEL_CPUP #ifdef LOSCFG_KERNEL_CPUP
(VOID)memset_s((VOID *)g_taskCpupAll, sizeof(g_taskCpupAll), 0, sizeof(g_taskCpupAll));//置零 (VOID)memset_s((VOID *)g_taskCpupAll, sizeof(g_taskCpupAll), 0, sizeof(g_taskCpupAll));
(VOID)memset_s((VOID *)g_taskCpup10s, sizeof(g_taskCpup10s), 0, sizeof(g_taskCpup10s));//置零 (VOID)memset_s((VOID *)g_taskCpup10s, sizeof(g_taskCpup10s), 0, sizeof(g_taskCpup10s));
(VOID)memset_s((VOID *)g_taskCpup1s, sizeof(g_taskCpup1s), 0, sizeof(g_taskCpup1s));//置零 (VOID)memset_s((VOID *)g_taskCpup1s, sizeof(g_taskCpup1s), 0, sizeof(g_taskCpup1s));
#endif #endif
(VOID)memset_s((VOID *)g_taskWaterLine, sizeof(g_taskWaterLine), 0, sizeof(g_taskWaterLine));//置零 (VOID)memset_s((VOID *)g_taskWaterLine, sizeof(g_taskWaterLine), 0, sizeof(g_taskWaterLine));
//如果没有调度器自旋锁，为该进程添加调度器自旋锁
if (LOS_SpinHeld(&g_taskSpin) == FALSE) { if (LOS_SpinHeld(&g_taskSpin) == FALSE) {
SCHEDULER_LOCK(intSave); SCHEDULER_LOCK(intSave);
lockFlag = TRUE; lockFlag = TRUE;
} }
//如果需要将进程信息备份
if (backupFlag == TRUE) { if (backupFlag == TRUE) {
//将进程信息备份到tcbArray
ret = memcpy_s(tcbArray, size, g_taskCBArray, size); ret = memcpy_s(tcbArray, size, g_taskCBArray, size);
//如果没有备份成果返回错误
if (ret != EOK) { if (ret != EOK) {
return LOS_NOK; return LOS_NOK;
} }
} }
#ifdef LOSCFG_KERNEL_CPUP #ifdef LOSCFG_KERNEL_CPUP
(VOID)LOS_AllCpuUsage(LOSCFG_BASE_CORE_TSK_LIMIT, g_taskCpupAll, CPUP_ALL_TIME, 1);//显示CPU所有时段的使用率信息 (VOID)LOS_AllCpuUsage(LOSCFG_BASE_CORE_TSK_LIMIT, g_taskCpupAll, CPUP_ALL_TIME, 1);
(VOID)LOS_AllCpuUsage(LOSCFG_BASE_CORE_TSK_LIMIT, g_taskCpup10s, CPUP_LAST_TEN_SECONDS, 1);//显示CPU最近10s的使用率信息 (VOID)LOS_AllCpuUsage(LOSCFG_BASE_CORE_TSK_LIMIT, g_taskCpup10s, CPUP_LAST_TEN_SECONDS, 1);
(VOID)LOS_AllCpuUsage(LOSCFG_BASE_CORE_TSK_LIMIT, g_taskCpup1s, CPUP_LAST_ONE_SECONDS, 1);//显示CPU最近1s的使用率信息 (VOID)LOS_AllCpuUsage(LOSCFG_BASE_CORE_TSK_LIMIT, g_taskCpup1s, CPUP_LAST_ONE_SECONDS, 1);
#endif #endif
//获取进程的栈水位信息
OsShellCmdTaskWaterLineGet(tcbArray); OsShellCmdTaskWaterLineGet(tcbArray);
//如果进程有调度器自旋锁，将该进程解锁
if (lockFlag == TRUE) { if (lockFlag == TRUE) {
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
} }
//打印进程信息标题
OsShellCmdTskInfoTitle(); OsShellCmdTskInfoTitle();
//打印进程信息的数据
OsShellCmdTskInfoData(tcbArray); OsShellCmdTskInfoData(tcbArray);
//如果进程信息数据备份成果，释放tcbArrayd的内存空间
if (backupFlag == TRUE) { if (backupFlag == TRUE) {
(VOID)LOS_MemFree(m_aucSysMem1, tcbArray); (VOID)LOS_MemFree(m_aucSysMem1, tcbArray);
} }
} else { } else {
//调用 OsTaskBackTrace函数来获取该任务的回溯信息。
OsTaskBackTrace(taskId); OsTaskBackTrace(taskId);
} }
@ -365,34 +330,29 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskId)
} }
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
//这个函数用于处理task命令，通过各种参数输出结果
LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv) LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv)
{ {
size_t taskId; size_t taskId;
CHAR *endPtr = NULL; CHAR *endPtr = NULL;
//当参数数量合法时
if (argc < 2) { /* 2:Just as number of parameters */ if (argc < 2) { /* 2:Just as number of parameters */
//如果没有参数，进程号是所有进程
if (argc == 0) { if (argc == 0) {
taskId = OS_ALL_TASK_MASK; taskId = OS_ALL_TASK_MASK;
//存在一个参数为进程号
} else { } else {
taskId = strtoul(argv[0], &endPtr, 0); taskId = strtoul(argv[0], &endPtr, 0);
//如果进程号不合法，打印错误信息
if ((*endPtr != 0) || (taskId >= g_taskMaxNum)) { if ((*endPtr != 0) || (taskId >= g_taskMaxNum)) {
PRINTK("\ntask ID can't access %s.\n", argv[0]); PRINTK("\ntask ID can't access %s.\n", argv[0]);
return OS_ERROR; return OS_ERROR;
} }
} }
//调用OsShellCmdTskInfoGet函数，输出该进程的进程信息
return OsShellCmdTskInfoGet((UINT32)taskId); return OsShellCmdTskInfoGet((UINT32)taskId);
} else { } else {
//参数不合法，打印错误信息
PRINTK("\nUsage: task or task ID\n"); PRINTK("\nUsage: task or task ID\n");
return OS_ERROR; return OS_ERROR;
} }
} }
//注册Shell命令task，调用OsShellCmdDumpTask，根据参数（进程号或者没有参数）获取进程信息并输出。
SHELLCMD_ENTRY(task_shellcmd, CMD_TYPE_EX, "task", 1, (CmdCallBackFunc)OsShellCmdDumpTask); SHELLCMD_ENTRY(task_shellcmd, CMD_TYPE_EX, "task", 1, (CmdCallBackFunc)OsShellCmdDumpTask);
#endif #endif

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

@ -31,7 +31,6 @@
* @ingroup kernel * @ingroup kernel
*/ */
//在LiteOS操作系统中，atomic.h头文件通常用于提供原子操作的支持。原子操作是不可中断的操作，它可以确保在多线程环境中对共享资源进行安全的访问和修改。
#ifndef _ARCH_GENERIC_ATOMIC_H #ifndef _ARCH_GENERIC_ATOMIC_H
#define _ARCH_GENERIC_ATOMIC_H #define _ARCH_GENERIC_ATOMIC_H
@ -45,26 +44,17 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifndef LOSCFG_KERNEL_SMP #ifndef LOSCFG_KERNEL_SMP
/*ArchAtomicRead 函数用于原子读取一个整数变量的值。
它将一个指向原子变量的指针 v 强制转换为 volatile INT32 类型的指针，
并返回该指针所指向的值。*/
STATIC INLINE INT32 ArchAtomicRead(const Atomic *v) STATIC INLINE INT32 ArchAtomicRead(const Atomic *v)
{ {
return *(volatile INT32 *)v; return *(volatile INT32 *)v;
} }
/*ArchAtomicSet 函数用于原子设置一个整数变量的值。
它将一个指向原子变量的指针 v 强制转换为 volatile INT32 类型的指针，
并将 setVal 的值赋给该指针所指向的变量。*/
STATIC INLINE VOID ArchAtomicSet(Atomic *v, INT32 setVal) STATIC INLINE VOID ArchAtomicSet(Atomic *v, INT32 setVal)
{ {
*(volatile INT32 *)v = setVal; *(volatile INT32 *)v = setVal;
} }
/*ArchAtomicAdd 函数用于原子增加一个整数变量的值。
它先保存当前中断状态，然后在关闭中断的情况下，将 addVal 加到指针 v 所指向的变量上，
并返回增加后的值。
最后，恢复之前保存的中断状态。*/
STATIC INLINE INT32 ArchAtomicAdd(Atomic *v, INT32 addVal) STATIC INLINE INT32 ArchAtomicAdd(Atomic *v, INT32 addVal)
{ {
UINT32 intSave; UINT32 intSave;
@ -76,9 +66,6 @@ STATIC INLINE INT32 ArchAtomicAdd(Atomic *v, INT32 addVal)
return *v; return *v;
} }
/*ArchAtomicSub 函数用于原子减少一个整数变量的值。
它的实现与 ArchAtomicAdd 类似，
只是将 subVal 减去指针 v 所指向的变量。*/
STATIC INLINE INT32 ArchAtomicSub(Atomic *v, INT32 subVal) STATIC INLINE INT32 ArchAtomicSub(Atomic *v, INT32 subVal)
{ {
UINT32 intSave; UINT32 intSave;
@ -90,10 +77,6 @@ STATIC INLINE INT32 ArchAtomicSub(Atomic *v, INT32 subVal)
return *v; return *v;
} }
/*ArchAtomicInc 函数用于原子增加一个整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 addr 指向的变量加 1，
最后恢复之前保存的中断状态。*/
STATIC INLINE VOID ArchAtomicInc(Atomic *addr) STATIC INLINE VOID ArchAtomicInc(Atomic *addr)
{ {
UINT32 intSave; UINT32 intSave;
@ -103,7 +86,6 @@ STATIC INLINE VOID ArchAtomicInc(Atomic *addr)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
//ArchAtomicIncRet 函数与 ArchAtomicInc 类似，但它还返回增加后的变量值。
STATIC INLINE INT32 ArchAtomicIncRet(Atomic *addr) STATIC INLINE INT32 ArchAtomicIncRet(Atomic *addr)
{ {
UINT32 intSave; UINT32 intSave;
@ -114,7 +96,6 @@ STATIC INLINE INT32 ArchAtomicIncRet(Atomic *addr)
return *addr; return *addr;
} }
//ArchAtomicDec 函数用于原子减少一个整数变量的值。它的实现类似于 ArchAtomicInc，只是将指针 addr 指向的变量减 1。
STATIC INLINE VOID ArchAtomicDec(Atomic *addr) STATIC INLINE VOID ArchAtomicDec(Atomic *addr)
{ {
UINT32 intSave; UINT32 intSave;
@ -124,7 +105,6 @@ STATIC INLINE VOID ArchAtomicDec(Atomic *addr)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
//ArchAtomicDecRet 函数与 ArchAtomicDec 类似，但它还返回减少后的变量值。
STATIC INLINE INT32 ArchAtomicDecRet(Atomic *addr) STATIC INLINE INT32 ArchAtomicDecRet(Atomic *addr)
{ {
UINT32 intSave; UINT32 intSave;
@ -135,10 +115,6 @@ STATIC INLINE INT32 ArchAtomicDecRet(Atomic *addr)
return *addr; return *addr;
} }
/*ArchAtomic64Read 函数用于原子读取一个 64 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
读取指针 v 指向的 64 位整数变量的值，
最后恢复之前保存的中断状态，并返回读取的值。*/
STATIC INLINE INT64 ArchAtomic64Read(const Atomic64 *v) STATIC INLINE INT64 ArchAtomic64Read(const Atomic64 *v)
{ {
UINT32 intSave; UINT32 intSave;
@ -151,10 +127,6 @@ STATIC INLINE INT64 ArchAtomic64Read(const Atomic64 *v)
return val; return val;
} }
/*ArchAtomic64Set 函数用于原子设置一个 64 位整数变量的值为 setVal。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量设置为 setVal，
最后恢复之前保存的中断状态。*/
STATIC INLINE VOID ArchAtomic64Set(Atomic64 *v, INT64 setVal) STATIC INLINE VOID ArchAtomic64Set(Atomic64 *v, INT64 setVal)
{ {
UINT32 intSave; UINT32 intSave;
@ -164,10 +136,6 @@ STATIC INLINE VOID ArchAtomic64Set(Atomic64 *v, INT64 setVal)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
/*ArchAtomic64Add 函数用于原子增加一个 64 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量增加 addVal，然后将增加后的值赋给变量 val，
最后恢复之前保存的中断状态，并返回 val。*/
STATIC INLINE INT64 ArchAtomic64Add(Atomic64 *v, INT64 addVal) STATIC INLINE INT64 ArchAtomic64Add(Atomic64 *v, INT64 addVal)
{ {
UINT32 intSave; UINT32 intSave;
@ -181,9 +149,6 @@ STATIC INLINE INT64 ArchAtomic64Add(Atomic64 *v, INT64 addVal)
return val; return val;
} }
/*ArchAtomic64Sub 函数用于原子减少一个 64 位整数变量的值。
它的实现类似于 ArchAtomic64Add，
只是将指针 v 指向的变量减去 subVal。*/
STATIC INLINE INT64 ArchAtomic64Sub(Atomic64 *v, INT64 subVal) STATIC INLINE INT64 ArchAtomic64Sub(Atomic64 *v, INT64 subVal)
{ {
UINT32 intSave; UINT32 intSave;
@ -197,8 +162,6 @@ STATIC INLINE INT64 ArchAtomic64Sub(Atomic64 *v, INT64 subVal)
return val; return val;
} }
/*ArchAtomic64Inc 函数用于原子增加一个 64 位整数变量的值。
它的实现类似于 ArchAtomic64Add，只是将增加的值固定为 1。*/
STATIC INLINE VOID ArchAtomic64Inc(Atomic64 *v) STATIC INLINE VOID ArchAtomic64Inc(Atomic64 *v)
{ {
UINT32 intSave; UINT32 intSave;
@ -208,7 +171,6 @@ STATIC INLINE VOID ArchAtomic64Inc(Atomic64 *v)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
//ArchAtomic64IncRet 函数与 ArchAtomic64Inc 类似，但它还返回增加后的变量值。
STATIC INLINE INT64 ArchAtomic64IncRet(Atomic64 *v) STATIC INLINE INT64 ArchAtomic64IncRet(Atomic64 *v)
{ {
UINT32 intSave; UINT32 intSave;
@ -222,9 +184,6 @@ STATIC INLINE INT64 ArchAtomic64IncRet(Atomic64 *v)
return val; return val;
} }
/*ArchAtomic64Dec 函数用于原子减少一个 64 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，将指针 v 指向的变量减去 1，
最后恢复之前保存的中断状态。*/
STATIC INLINE VOID ArchAtomic64Dec(Atomic64 *v) STATIC INLINE VOID ArchAtomic64Dec(Atomic64 *v)
{ {
UINT32 intSave; UINT32 intSave;
@ -234,7 +193,6 @@ STATIC INLINE VOID ArchAtomic64Dec(Atomic64 *v)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
//ArchAtomic64DecRet 函数与 ArchAtomic64Dec 类似，但它还返回减少后的变量值。
STATIC INLINE INT64 ArchAtomic64DecRet(Atomic64 *v) STATIC INLINE INT64 ArchAtomic64DecRet(Atomic64 *v)
{ {
UINT32 intSave; UINT32 intSave;
@ -248,10 +206,6 @@ STATIC INLINE INT64 ArchAtomic64DecRet(Atomic64 *v)
return val; return val;
} }
/*ArchAtomicXchg32bits 函数用于原子交换一个 32 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量的值赋给 prevVal，再将变量 v 的值设置为 val，
最后恢复之前保存的中断状态，并返回原先的值 prevVal。*/
STATIC INLINE INT32 ArchAtomicXchg32bits(Atomic *v, INT32 val) STATIC INLINE INT32 ArchAtomicXchg32bits(Atomic *v, INT32 val)
{ {
UINT32 intSave; UINT32 intSave;
@ -265,7 +219,6 @@ STATIC INLINE INT32 ArchAtomicXchg32bits(Atomic *v, INT32 val)
return prevVal; return prevVal;
} }
//ArchAtomicXchg64bits 函数类似于 ArchAtomicXchg32bits，但它用于原子交换一个 64 位整数变量的值。
STATIC INLINE INT64 ArchAtomicXchg64bits(Atomic64 *v, INT64 val) STATIC INLINE INT64 ArchAtomicXchg64bits(Atomic64 *v, INT64 val)
{ {
UINT32 intSave; UINT32 intSave;
@ -279,11 +232,6 @@ STATIC INLINE INT64 ArchAtomicXchg64bits(Atomic64 *v, INT64 val)
return prevVal; return prevVal;
} }
/*ArchAtomicCmpXchg32bits 函数用于原子比较和交换一个 32 位整数变量的值。
它首先保存当前中断状态 intSave，然后在关闭中断的情况下，
将指针 v 指向的变量的值赋给 prevVal，接着判断 prevVal 是否等于 oldVal，
如果相等，则将变量 v 的值设置为 val，最后恢复之前保存的中断状态，
并返回是否执行了交换操作的布尔值。*/
STATIC INLINE BOOL ArchAtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal) STATIC INLINE BOOL ArchAtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal)
{ {
UINT32 intSave; UINT32 intSave;
@ -299,7 +247,6 @@ STATIC INLINE BOOL ArchAtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal)
return (prevVal != oldVal); return (prevVal != oldVal);
} }
//ArchAtomicCmpXchg64bits 函数类似于 ArchAtomicCmpXchg32bits，但它用于原子比较和交换一个 64 位整数变量的值。
STATIC INLINE BOOL ArchAtomicCmpXchg64bits(Atomic64 *v, INT64 val, INT64 oldVal) STATIC INLINE BOOL ArchAtomicCmpXchg64bits(Atomic64 *v, INT64 val, INT64 oldVal)
{ {
UINT32 intSave; 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 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//在LiteOS操作系统中，console头文件通常用于定义与控制台交互相关的函数和数据结构。
#ifndef _CONSOLE_H #ifndef _CONSOLE_H
#define _CONSOLE_H #define _CONSOLE_H
//代码中，首先使用了条件编译防护，以确保头文件内容只被包含一次。接着定义了控制台输入输出缓冲区的大小，并声明了控制台初始化、打印和读取等函数。
#include "los_config.h"//引用了系统配置文件，用于获取操作系统的一些设置和属性。 #include "los_config.h"
#ifdef LOSCFG_FS_VFS//使用条件编译指令判断是否定义了宏LOSCFG_FS_VFS，如果已经定义，则编译下面的代码块，否则跳过。 #ifdef LOSCFG_FS_VFS
#include "termios.h"//包含了 POSIX 终端控制定义的头文件，用于对终端进行控制。 #include "termios.h"
#ifdef LOSCFG_NET_TELNET//使用条件编译指令判断是否定义了宏,如果已经定义，则编译下面的代码块，否则跳过。 #ifdef LOSCFG_NET_TELNET
#include "telnet_dev.h"//包含了 Telnet 设备驱动的头文件，用于实现 Telnet 连接。 #include "telnet_dev.h"
#endif//结束条件编译指令。 #endif
#include "virtual_serial.h"//包含了虚拟串口的头文件，用于实现虚拟串口的功能。 #include "virtual_serial.h"
#include "los_ringbuf.h"//包含了环形缓冲区的头文件，用于实现缓冲区的读写操作。 #include "los_ringbuf.h"
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
@ -57,76 +57,76 @@ extern "C" {
#define CONSOLE "/dev/console" #define CONSOLE "/dev/console"
#define CONSOLE_NAMELEN 16 #define CONSOLE_NAMELEN 16
//这段代码定义了一些宏和常量，它们的含义如下：
#define CONSOLE_CMD_RD_BLOCK_SERIAL 0x104//表示从串口读取数据的阻塞命令，其值为0x104。 #define CONSOLE_CMD_RD_BLOCK_SERIAL 0x104
#define CONSOLE_CMD_RD_BLOCK_TELNET 101//表示从Telnet连接读取数据的阻塞命令，其值为101。 #define CONSOLE_CMD_RD_BLOCK_TELNET 101
#define CONSOLE_RD_BLOCK 1//表示阻塞模式，其值为1。 #define CONSOLE_RD_BLOCK 1
#define CONSOLE_RD_NONBLOCK 0//表示非阻塞模式，其值为0。 #define CONSOLE_RD_NONBLOCK 0
#define CONSOLE_SHELL_KEY_EVENT 0x112//表示shell键盘事件，其值为0x112。 #define CONSOLE_SHELL_KEY_EVENT 0x112
#define CONSOLE_SHELL_EXITED 0x400//表示shell已退出，其值为0x400。 #define CONSOLE_SHELL_EXITED 0x400
#define CONSOLE_CONTROL_RIGHTS_CAPTURE 201//表示控制权被捕获，其值为201。 #define CONSOLE_CONTROL_RIGHTS_CAPTURE 201
#define CONSOLE_CONTROL_RIGHTS_RELEASE 202//表示控制权被释放，其值为202。 #define CONSOLE_CONTROL_RIGHTS_RELEASE 202
#define CONSOLE_CONTROL_CAPTURE_LINE 203//表示捕获行命令，其值为203。 #define CONSOLE_CONTROL_CAPTURE_LINE 203
#define CONSOLE_CONTROL_CAPTURE_CHAR 204//表示捕获字符命令，其值为204。 #define CONSOLE_CONTROL_CAPTURE_CHAR 204
#define CONSOLE_FIFO_SIZE 1024//表示控制台FIFO（First In First Out）缓冲区大小，其值为1024。 #define CONSOLE_FIFO_SIZE 1024
#define CONSOLE_NUM 2//表示控制台数量，其值为2。 #define CONSOLE_NUM 2
typedef struct { typedef struct {
Ringbuf ringbuf; /* Ring buffer *///表示环形缓冲区，它可能是一个用于缓存数据的循环队列或者环形链表。 Ringbuf ringbuf; /* Ring buffer */
EVENT_CB_S sendEvent; /* Inform telnet send task *///表示向telnet发送任务发送事件的回调函数。 EVENT_CB_S sendEvent; /* Inform telnet send task */
} RingbufSendCB; } RingbufSendCB;
typedef struct { typedef struct {
UINT32 consoleID;//表示控制台的ID。 UINT32 consoleID;
UINT32 consoleType;//表示控制台的类型。 UINT32 consoleType;
UINT32 consoleSem;//表示用于同步的控制台信号量。 UINT32 consoleSem;
UINT32 shellEntryId;//表示shell的入口ID。 UINT32 shellEntryId;
UINT32 consoleMask;//表示控制台的掩码。 UINT32 consoleMask;
struct inode *devInode;//表示设备节点。 struct inode *devInode;
CHAR *name;//表示控制台的名称。 CHAR *name;
INT32 fd;//表示文件描述符。 INT32 fd;
UINT32 refCount;//表示引用计数。 UINT32 refCount;
BOOL isNonBlock;//表示是否为非阻塞模式。 BOOL isNonBlock;
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
VOID *shellHandle;//表示shell的句柄。 VOID *shellHandle;
#endif #endif
UINT32 sendTaskID;//表示发送任务的ID。 UINT32 sendTaskID;
RingbufSendCB *ringbufSendCB;//表示环形缓冲区发送回调。 RingbufSendCB *ringbufSendCB;
UINT8 fifo[CONSOLE_FIFO_SIZE];//表示控制台的FIFO缓冲区。 UINT8 fifo[CONSOLE_FIFO_SIZE];
UINT32 fifoOut;//表示FIFO缓冲区的输出位置。 UINT32 fifoOut;
UINT32 fifoIn;//表示FIFO缓冲区的输入位置。 UINT32 fifoIn;
UINT32 currentLen;//表示当前长度。 UINT32 currentLen;
struct termios consoleTermios;//表示控制台的终端属性。 struct termios consoleTermios;
} CONSOLE_CB; } CONSOLE_CB;
extern INT32 system_console_init(const CHAR *deviceName);//控制台初始化函数用于初始化控制台相关的资源和状态 extern INT32 system_console_init(const CHAR *deviceName);
extern INT32 system_console_deinit(const CHAR *deviceName);//控制台反初始化函数，用于释放控制台相关的资源和状态。 extern INT32 system_console_deinit(const CHAR *deviceName);
extern BOOL SetSerialNonBlock(const CONSOLE_CB *consoleCB);//设置串口为非阻塞模式。 extern BOOL SetSerialNonBlock(const CONSOLE_CB *consoleCB);
extern BOOL SetSerialBlock(const CONSOLE_CB *consoleCB);//设置串口为阻塞模式。 extern BOOL SetSerialBlock(const CONSOLE_CB *consoleCB);
extern BOOL SetTelnetNonBlock(const CONSOLE_CB *consoleCB);//设置Telnet连接为非阻塞模式。 extern BOOL SetTelnetNonBlock(const CONSOLE_CB *consoleCB);
extern BOOL SetTelnetBlock(const CONSOLE_CB *consoleCB);//设置Telnet连接为阻塞模式。 extern BOOL SetTelnetBlock(const CONSOLE_CB *consoleCB);
extern CONSOLE_CB *OsGetConsoleByID(INT32 consoleId);//根据控制台ID获取控制台的控制块（Control Block）。 extern CONSOLE_CB *OsGetConsoleByID(INT32 consoleId);
extern CONSOLE_CB *OsGetConsoleByTaskID(UINT32 taskId);//根据任务ID获取关联的控制台的控制块。 extern CONSOLE_CB *OsGetConsoleByTaskID(UINT32 taskId);
extern UINT32 ConsoleTaskReg(INT32 consoleId, UINT32 taskId);//将任务与指定的控制台进行关联。 extern UINT32 ConsoleTaskReg(INT32 consoleId, UINT32 taskId);
extern INT32 ConsoleUpdateFd(VOID);//更新控制台的文件描述符（File Descriptor）。 extern INT32 ConsoleUpdateFd(VOID);
extern BOOL ConsoleEnable(VOID);//使能控制台功能。 extern BOOL ConsoleEnable(VOID);
extern BOOL is_nonblock(const CONSOLE_CB *consoleCB);//判断控制台是否为非阻塞模式。 extern BOOL is_nonblock(const CONSOLE_CB *consoleCB);
extern BOOL IsConsoleOccupied(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 FilepOpen(struct file *filep, const struct file_operations_vfs *fops);
extern INT32 FilepClose(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 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 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 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 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 GetFilepOps(const struct file *filep, struct file **privFilep, const struct file_operations_vfs **fops);
#else #else
STATIC INLINE INT32 ConsoleUpdateFd(VOID)//这是一个函数声明，声明了一个名为ConsoleUpdateFd的静态内联函数，返回类型为INT32（32位整数），参数为空。根据函数体的实现为return -1;，该函数的作用是更新控制台的文件描述符（File Descriptor），并返回-1。 STATIC INLINE INT32 ConsoleUpdateFd(VOID)
{ {
return -1; return -1;
} }
#endif//这个宏表示结束了之前的条件编译指令#if。 #endif
#ifdef __cplusplus//这一组条件编译指令用于判断是否为C++编译环境。如果是C++编译环境，则将后面的代码块用extern "C"包裹起来，以保证C和C++之间的函数调用规则一致。 #ifdef __cplusplus
#if __cplusplus #if __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -53,9 +53,6 @@ extern "C" {
* *
* Solution: Decrease the maximum number of tasks. * 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) #define LOS_ERRNO_CPUP_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x00)
/** /**
@ -66,9 +63,6 @@ extern "C" {
* *
* Solution: Check whether the pointer to the input parameter is usable. * 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) #define LOS_ERRNO_CPUP_TASK_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x01)
/** /**
@ -79,9 +73,6 @@ extern "C" {
* *
* Solution: Check whether the CPU usage is initialized. * 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) #define LOS_ERRNO_CPUP_NO_INIT LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x02)
/** /**
@ -92,9 +83,6 @@ extern "C" {
* *
* Solution: Check whether the number of threads is applicable for the current operation. * 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) #define LOS_ERRNO_CPUP_MAXNUM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x03)
/** /**
@ -105,9 +93,6 @@ extern "C" {
* *
* Solution: Check whether the target thread is created. * 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) #define LOS_ERRNO_CPUP_THREAD_NO_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x04)
/** /**
@ -118,22 +103,12 @@ extern "C" {
* *
* Solution: Check whether the target task ID is applicable for the current operation. * 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) #define LOS_ERRNO_CPUP_TSK_ID_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x05)
/** /**
* @ingroup los_cpup * @ingroup los_cpup
* The structure of the CPU usage information of all tasks. * 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 { typedef struct tagCpupInfo {
UINT16 usStatus; /**< The task status. */ UINT16 usStatus; /**< The task status. */
UINT32 uwUsage; /**< CPU usage of all tasks. It is a permillage. And the value range is [0,1000]. */ UINT32 uwUsage; /**< CPU usage of all tasks. It is a permillage. And the value range is [0,1000]. */
@ -143,13 +118,9 @@ typedef struct tagCpupInfo {
* @ingroup los_cpup * @ingroup los_cpup
* The time period which the CPU usage collects in. * The time period which the CPU usage collects in.
*/ */
//用于表示 CPU 使用率的时间范围。
enum { enum {
//表示显示最近 10 秒钟的 CPU 使用率，值为0。
CPUP_LAST_TEN_SECONDS = 0, /**< Display CPU usage in the last ten seconds, the value is 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. */ 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. */ CPUP_ALL_TIME = 0xffff /**< Display CPU usage from system startup to now, the value is 0xffff. */
}; };
@ -178,7 +149,6 @@ enum {
* @see LOS_HistoryTaskCpuUsage | LOS_AllCpuUsage * @see LOS_HistoryTaskCpuUsage | LOS_AllCpuUsage
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
//获取历史系统CPU使用率。参数 mode 是用来指定获取 CPU 使用率的时间范围或者其他相关设置。
extern UINT32 LOS_HistorySysCpuUsage(UINT32 mode); extern UINT32 LOS_HistorySysCpuUsage(UINT32 mode);
/** /**
@ -212,9 +182,6 @@ extern UINT32 LOS_HistorySysCpuUsage(UINT32 mode);
* @see LOS_HistorySysCpuUsage * @see LOS_HistorySysCpuUsage
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
/*用于获取历史任务的CPU使用率。
其中 taskId 参数表示任务的ID或标识符，
mode 参数可能表示获取CPU使用率的模式或配置选项。*/
extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskId, UINT32 mode); extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskId, UINT32 mode);
/** /**
@ -257,10 +224,6 @@ extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskId, UINT32 mode);
* <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul> * <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V100R001C00 * @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); extern UINT32 LOS_AllCpuUsage(UINT16 maxNum, CPUP_INFO_S *cpupInfo, UINT32 mode, UINT16 flag);
/** /**
@ -281,10 +244,6 @@ 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> * <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
/*LOS_CpupReset 函数会遍历系统中所有任务和中断，
将它们的 CPU 使用率统计信息清零。
这样，在下一次任务或中断执行时，
操作系统就会重新开始记录它们的 CPU 使用率。*/
extern VOID LOS_CpupReset(VOID); extern VOID LOS_CpupReset(VOID);
#ifdef __cplusplus #ifdef __cplusplus

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

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

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

@ -46,31 +46,31 @@ extern "C" {
* @ingroup los_errno * @ingroup los_errno
* OS error code flag. It is a 24-bit unsigned integer. Its value is 0x000000U. * OS error code flag. It is a 24-bit unsigned integer. Its value is 0x000000U.
*/ */
#define LOS_ERRNO_OS_ID (0x00U << 16)//宏定义为 0x00U << 16，表示操作系统相关的错误码。 #define LOS_ERRNO_OS_ID (0x00U << 16)
/** /**
* @ingroup los_errno * @ingroup los_errno
* Define the error level as informative. It is a 32-bit unsigned integer. Its value is 0x00000000U. * Define the error level as informative. It is a 32-bit unsigned integer. Its value is 0x00000000U.
*/ */
#define LOS_ERRTYPE_NORMAL (0x00U << 24)//宏定义表示错误级别为 "informative"（信息级别），其值为 0x00U << 24。 #define LOS_ERRTYPE_NORMAL (0x00U << 24)
/** /**
* @ingroup los_errno * @ingroup los_errno
* Define the error level as warning. It is a 32-bit unsigned integer. Its value is 0x01000000U. * Define the error level as warning. It is a 32-bit unsigned integer. Its value is 0x01000000U.
*/ */
#define LOS_ERRTYPE_WARN (0x01U << 24)//宏定义表示错误级别为 "warning"（警告级别），其值为 0x01U << 24。 #define LOS_ERRTYPE_WARN (0x01U << 24)
/** /**
* @ingroup los_errno * @ingroup los_errno
* Define the error level as critical. It is a 32-bit unsigned integer. Its value is 0x02000000U. * Define the error level as critical. It is a 32-bit unsigned integer. Its value is 0x02000000U.
*/ */
#define LOS_ERRTYPE_ERROR (0x02U << 24)//宏定义表示错误级别为 "critical"（严重级别），其值为 0x02U << 24。 #define LOS_ERRTYPE_ERROR (0x02U << 24)
/** /**
* @ingroup los_errno * @ingroup los_errno
* Define the error level as fatal. It is a 32-bit unsigned integer. Its value is 0x03000000U. * Define the error level as fatal. It is a 32-bit unsigned integer. Its value is 0x03000000U.
*/ */
#define LOS_ERRTYPE_FATAL (0x03U << 24)//宏定义表示错误级别为 "fatal"（致命级别），其值为 0x03U << 24。 #define LOS_ERRTYPE_FATAL (0x03U << 24)
/** /**
* @ingroup los_errno * @ingroup los_errno
@ -82,14 +82,6 @@ extern "C" {
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li> * <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul> * </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) \ #define LOS_ERRNO_OS_FATAL(MID, ERRNO) \
(LOS_ERRTYPE_FATAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) (LOS_ERRTYPE_FATAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
@ -103,15 +95,6 @@ LOS_ERRNO_OS_ID
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li> * <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul> * </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) \ #define LOS_ERRNO_OS_ERROR(MID, ERRNO) \
(LOS_ERRTYPE_ERROR | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) (LOS_ERRTYPE_ERROR | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
@ -125,15 +108,6 @@ LOS_ERRNO_OS_ID
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li> * <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul> * </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) \ #define LOS_ERRNO_OS_WARN(MID, ERRNO) \
(LOS_ERRTYPE_WARN | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) (LOS_ERRTYPE_WARN | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
@ -147,29 +121,13 @@ LOS_ERRNO_OS_ID
* <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li> * <li>0-7 bits indicate the error code number. It is specified by ERRNO.</li>
* </ul> * </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) \ #define LOS_ERRNO_OS_NORMAL(MID, ERRNO) \
(LOS_ERRTYPE_NORMAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) (LOS_ERRTYPE_NORMAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO)))
/** /**
* @ingroup los_errno * @ingroup los_errno
* Define the ID of each module in kernel. The ID is used in error code. * 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 { enum LOS_MOUDLE_ID {
LOS_MOD_SYS = 0x0, /**< System ID. Its value is 0x0. */ LOS_MOD_SYS = 0x0, /**< System ID. Its value is 0x0. */
LOS_MOD_MEM = 0x1, /**< Dynamic memory module ID. Its value is 0x1. */ 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 * @ingroup los_event
* Event reading mode: The task waits for all its expected events to occur. * 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 * @ingroup los_event
* Event reading mode: The task waits for any of its expected events to occur. * 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 * @ingroup los_event
* Event reading mode: The event flag is immediately cleared after the event is read. * 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 * @ingroup los_event
@ -69,14 +69,6 @@ extern "C" {
* Value: 0x02001c00. * Value: 0x02001c00.
* *
* Solution: Set bits excluding bit 25 of the event mask to events. * 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) #define LOS_ERRNO_EVENT_SETBIT_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x00)
@ -89,13 +81,6 @@ extern "C" {
* Solution: Increase the waiting time for event reading, or make another task write a * Solution: Increase the waiting time for event reading, or make another task write a
* mask for the event. * 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) #define LOS_ERRNO_EVENT_READ_TIMEOUT LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x01)
/** /**
@ -107,13 +92,6 @@ extern "C" {
* *
* Solution: Pass in a valid EVENTMASK value. * 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) #define LOS_ERRNO_EVENT_EVENTMASK_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x02)
/** /**
@ -124,15 +102,6 @@ extern "C" {
* *
* Solution: Read the event in a task. * 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) #define LOS_ERRNO_EVENT_READ_IN_INTERRUPT LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x03)
/** /**
@ -146,15 +115,6 @@ extern "C" {
* *
* Solution: Pass in a valid flag value. * 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) #define LOS_ERRNO_EVENT_FLAGS_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x04)
/** /**
@ -165,15 +125,6 @@ extern "C" {
* *
* Solution: Unlock the task and read the event. * 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) #define LOS_ERRNO_EVENT_READ_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x05)
/** /**
@ -184,14 +135,6 @@ extern "C" {
* *
* Solution: Check whether the input parameter is null. * 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) #define LOS_ERRNO_EVENT_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x06)
/** /**
@ -204,15 +147,6 @@ extern "C" {
* Solution: Read the event in a vailid task. * Solution: Read the event in a vailid task.
* @deprecated This error code is obsolete since LiteOS 5.0.0. * @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) #define LOS_ERRNO_EVENT_READ_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x07)
/** /**
@ -223,29 +157,12 @@ extern "C" {
* *
* Solution: Check whether the event list is not empty. * 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) #define LOS_ERRNO_EVENT_SHOULD_NOT_DESTORY LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x08)
/** /**
* @ingroup los_event * @ingroup los_event
* Event control structure * Event control structure
*/ */
/*这段代码定义了一个名为 tagEvent 的结构体，其中包含两个成员变量：
uwEventID：表示事件掩码，在事件控制块中指示已经逻辑处理的事件。
通常用于标识事件的类型或属性。
stEventList：是一个链表节点，用于将事件控制块进行链接，以支持对事件的管理操作。
此外，通过 typedef 关键字将 struct tagEvent 重新定义为 EVENT_CB_S 类型，
同时定义了指向 EVENT_CB_S 结构体的指针类型 PEVENT_CB_S。
这种结构体的设计通常用于事件管理模块，用于存储和管理事件相关的信息，
包括事件的标识和事件控制块的链表关系。
开发人员可以使用这样的结构体来实现事件的创建、删除、等待和触发等功能，
从而更好地管理系统中的异步事件，提高系统的并发处理能力。*/
typedef struct tagEvent { typedef struct tagEvent {
UINT32 uwEventID; /**< Event mask in the event control block, UINT32 uwEventID; /**< Event mask in the event control block,
indicating the event that has been logically processed. */ indicating the event that has been logically processed. */
@ -270,15 +187,6 @@ typedef struct tagEvent {
* @see LOS_EventClear * @see LOS_EventClear
* @since Huawei LiteOS V100R001C00 * @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); extern UINT32 LOS_EventInit(PEVENT_CB_S eventCB);
/** /**
@ -315,25 +223,6 @@ extern UINT32 LOS_EventInit(PEVENT_CB_S eventCB);
* @see LOS_EventRead | LOS_EventWrite * @see LOS_EventRead | LOS_EventWrite
* @since Huawei LiteOS V100R001C00 * @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); extern UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode);
/** /**
@ -374,24 +263,6 @@ extern UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode);
* @see LOS_EventPoll | LOS_EventWrite * @see LOS_EventPoll | LOS_EventWrite
* @since Huawei LiteOS V100R001C00 * @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); extern UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout);
/** /**
@ -440,17 +311,6 @@ extern UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events);
* @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite * @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite
* @since Huawei LiteOS V100R001C00 * @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); extern UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events);
/** /**
@ -473,22 +333,6 @@ extern UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events);
* @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite * @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite
* @since Huawei LiteOS V100R001C00 * @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); extern UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB);
#ifdef __cplusplus #ifdef __cplusplus

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

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

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

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

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

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

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

@ -54,7 +54,7 @@ enum LOAD_STRATEGY {
ZIP, ZIP,
NOZIP NOZIP
}; };
/*这是一个枚举类型的定义，名称为LOAD_STRATEGY。它包含两个成员：ZIP和NOZIP。*/
/** /**
* @ingroup los_dynload * @ingroup los_dynload
* Define the structure of the parameters used for dynamic. * Define the structure of the parameters used for dynamic.
@ -64,9 +64,7 @@ enum LOAD_STRATEGY {
typedef struct tagDynloadParam { typedef struct tagDynloadParam {
enum LOAD_STRATEGY enLoadStrategy; enum LOAD_STRATEGY enLoadStrategy;
} DYNLOAD_PARAM_S; } DYNLOAD_PARAM_S;
/*这个结构体可以用来存储动态加载的参数信息，
其中enLoadStrategy成员表示加载策略，可以是ZIP或者NOZIP。通过使用这个结构体，
可以将加载策略作为参数传递给相关的函数或模块。*/
/** /**
* @ingroup los_dynload * @ingroup los_dynload
* @brief Register the dynamic parameters. * @brief Register the dynamic parameters.
@ -86,8 +84,7 @@ typedef struct tagDynloadParam {
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID LOS_DynParamReg(DYNLOAD_PARAM_S *dynloadParam); extern VOID LOS_DynParamReg(DYNLOAD_PARAM_S *dynloadParam);
/*通过调用LOS_DynParamReg函数并传递一个指向DYNLOAD_PARAM_S类型对象的指针，
可以将动态加载的参数信息注册到相关的系统或模块中。*/
/** /**
* @ingroup los_dynload * @ingroup los_dynload
* @brief Load a shared object file. * @brief Load a shared object file.
@ -139,7 +136,7 @@ extern VOID *LOS_MemLoad(const CHAR *elfFileName, UINT32 fileNameLen,
const CHAR *elfFileBuf, UINT32 bufLen); const CHAR *elfFileBuf, UINT32 bufLen);
#endif /* LOSCFG_DYNLOAD_DYN_FROM_MEM */ #endif /* LOSCFG_DYNLOAD_DYN_FROM_MEM */
#endif /* LOSCFG_KERNEL_DYNLOAD_DYN */ #endif /* LOSCFG_KERNEL_DYNLOAD_DYN */
/*这段代码中使用了条件编译指令#ifdef和#endif，用于在不同的编译环境下选择是否启用动态加载功能。*/
#ifdef LOSCFG_KERNEL_DYNLOAD_REL #ifdef LOSCFG_KERNEL_DYNLOAD_REL
/** /**
* @ingroup los_dynload * @ingroup los_dynload
@ -163,9 +160,7 @@ extern VOID *LOS_MemLoad(const CHAR *elfFileName, UINT32 fileNameLen,
*/ */
extern VOID *LOS_ObjLoad(CHAR *elfFileName); extern VOID *LOS_ObjLoad(CHAR *elfFileName);
#endif /* LOSCFG_KERNEL_DYNLOAD_REL */ #endif /* LOSCFG_KERNEL_DYNLOAD_REL */
/*如果宏定义LOSCFG_KERNEL_DYNLOAD_REL被定义，
则表示启用了动态链接库的重定位功能，此时函数LOS_ObjLoad被声明为外部函数，
并接受一个指向字符串类型（CHAR）的指针作为参数，返回一个VOID类型的指针。*/
/** /**
* @ingroup los_dynload * @ingroup los_dynload
* @brief Unload a module. * @brief Unload a module.
@ -187,8 +182,7 @@ extern VOID *LOS_ObjLoad(CHAR *elfFileName);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern INT32 LOS_ModuleUnload(VOID *handle); extern INT32 LOS_ModuleUnload(VOID *handle);
/*通过调用LOS_ModuleUnload函数并传递一个动态库的句柄，
可以卸载该动态库并释放相关资源。*/
/** /**
* @ingroup los_dynload * @ingroup los_dynload
* @brief Destroy a dynamic loader. * @brief Destroy a dynamic loader.
@ -209,9 +203,7 @@ extern INT32 LOS_ModuleUnload(VOID *handle);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID LOS_LdDestroy(VOID); extern VOID LOS_LdDestroy(VOID);
/*这段代码声明了一个外部函数LOS_LdDestroy，该函数没有参数和返回值。
通过调用LOS_LdDestroy函数，可以销毁动态加载器（Loader），释放相关资源*/
/** /**
* @ingroup los_dynload * @ingroup los_dynload
* @brief Search for a symbol address. * @brief Search for a symbol address.
@ -258,8 +250,7 @@ extern VOID *LOS_FindSymByName(VOID *handle, CHAR *name);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern INT32 LOS_PathAdd(CHAR *path); extern INT32 LOS_PathAdd(CHAR *path);
/*通过调用LOS_PathAdd函数并传递一个路径，可以将该路径添加到动态库搜索路径中。
在动态链接库加载时，系统会按照一定的顺序搜索动态库*/
/** /**
* @ingroup los_dynload * @ingroup los_dynload
* @brief Set the memory pool address used by dynload * @brief Set the memory pool address used by dynload
@ -282,9 +273,7 @@ extern INT32 LOS_PathAdd(CHAR *path);
* @since Huawei LiteOS V200R002C00 * @since Huawei LiteOS V200R002C00
*/ */
extern BOOL LOS_DynMemPoolSet(VOID *memPool); extern BOOL LOS_DynMemPoolSet(VOID *memPool);
/*通过调用LOS_DynMemPoolSet函数并传递一个内存池指针，
可以设置动态内存池，用于在加载和执行动态链接库时分配内存。动态链接库可能
需要在运行时分配内存来存储数据和执行代码，因此需要提供一个合适的内存池。*/
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
} }

70
src/kernel/include/los_list.h
Unescape View File

@ -50,10 +50,6 @@ typedef struct LOS_DL_LIST {
struct LOS_DL_LIST *pstPrev; /**< Current node's pointer to the previous node */ struct LOS_DL_LIST *pstPrev; /**< Current node's pointer to the previous node */
struct LOS_DL_LIST *pstNext; /**< Current node's pointer to the next node */ struct LOS_DL_LIST *pstNext; /**< Current node's pointer to the next node */
} LOS_DL_LIST; } LOS_DL_LIST;
/*这种结构体通常用于实现双向链表数据结构。
通过在每个节点中嵌入LOS_DL_LIST结构体，
可以将多个节点连接起来形成链表。
*/
/** /**
* @ingroup los_list * @ingroup los_list
@ -78,11 +74,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListInit(LOS_DL_LIST *list)
list->pstNext = list; list->pstNext = list;
list->pstPrev = list; list->pstPrev = list;
} }
/*这段代码定义了一个静态内联函数LOS_ListInit，
该函数接受一个指向LOS_DL_LIST结构体的指针list作为参数，没有返回值。
函数的作用是将传入的链表初始化为空，即将链表头节点的pstNext和pstPrev指
针都指向头节点本身，表示链表中没有其他节点。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Point to the next node of the current node. * @brief Point to the next node of the current node.
@ -101,12 +93,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListInit(LOS_DL_LIST *list)
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
#define LOS_DL_LIST_FIRST(object) ((object)->pstNext) #define LOS_DL_LIST_FIRST(object) ((object)->pstNext)
/*这段代码定义了一个宏LOS_DL_LIST_FIRST(object)，
它接受一个指向LOS_DL_LIST结构体的指针object作为参数，
并返回object指向的节点的下一个节点的指针，即链表中的第一个节点。
这个宏的作用是方便地获取链表中的第一个节点，通过宏展开后，
可以直接访问链表头节点的下一个节点。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Point to the previous node of the current node. * @brief Point to the previous node of the current node.
@ -125,10 +112,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListInit(LOS_DL_LIST *list)
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
#define LOS_DL_LIST_LAST(object) ((object)->pstPrev) #define LOS_DL_LIST_LAST(object) ((object)->pstPrev)
/*这段代码是一个宏定义，用于获取双向链表中指定节点的前一个节点。
在这里，传入的参数 object 是一个指向双向链表节点的指针，
pstPrev 是该节点中指向前一个节点的指针。
该宏的功能是返回指定节点的前一个节点的指针。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Insert a new node to a doubly linked list. * @brief Insert a new node to a doubly linked list.
@ -154,13 +138,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListAdd(LOS_DL_LIST *list, LOS_DL_
list->pstNext->pstPrev = node; list->pstNext->pstPrev = node;
list->pstNext = node; list->pstNext = node;
} }
/*该函数将新节点插入到链表头部，具体步骤如下：
把新节点的 next 指针指向链表头部的下一个节点。
把新节点的 prev 指针指向链表头部。
把原链表头部的下一个节点的 prev 指针指向新节点。
把链表头部的 next 指针指向新节点。
通过这些步骤，新节点就被成功地添加到了链表头部。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Insert a node to a doubly linked list. * @brief Insert a node to a doubly linked list.
@ -183,10 +161,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListTailInsert(LOS_DL_LIST *list,
{ {
LOS_ListAdd(list->pstPrev, node); LOS_ListAdd(list->pstPrev, node);
} }
/*在该函数中，使用了宏定义 LOS_DL_LIST 来表示链表节点，
使用了 STATIC INLINE 关键字来定义内联函数，以提高代码执行效率。
函数的实现非常简单，只需调用双向链表的插入操作 LOS_ListAdd，
将新节点添加到链表头部的前一个节点即可。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Insert a node to a doubly linked list. * @brief Insert a node to a doubly linked list.
@ -235,12 +210,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListDelete(LOS_DL_LIST *node)
node->pstNext = NULL; node->pstNext = NULL;
node->pstPrev = NULL; node->pstPrev = NULL;
} }
/*该函数的实现非常简单，具体步骤如下：
把被删除节点的 next 节点的 prev 指针指向被删除节点的 prev 节点。
把被删除节点的 prev 节点的 next 指针指向被删除节点的 next 节点。
清空被删除节点的 next 指针和 prev 指针。
通过这些步骤，被指定的节点就从链表中被成功地删除了。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Identify whether a specified doubly linked list is empty or not. * @brief Identify whether a specified doubly linked list is empty or not.
@ -263,12 +233,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE BOOL LOS_ListEmpty(LOS_DL_LIST *list)
{ {
return (BOOL)(list->pstNext == list); return (BOOL)(list->pstNext == list);
} }
/*具体步骤如下：
判断链表头部的 pstNext 指针是否等于链表头部本身。
如果相等，返回 TRUE（表示链表为空）。
如果不相等，返回 FALSE（表示链表不为空）。
通过这些步骤，可以判断链表是否为空。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Obtain the offset of a structure member relative to the structure start address. * @brief Obtain the offset of a structure member relative to the structure start address.
@ -291,10 +256,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE BOOL LOS_ListEmpty(LOS_DL_LIST *list)
/* Obsolete API, please use LOS_OFF_SET_OF instead */ /* Obsolete API, please use LOS_OFF_SET_OF instead */
#define OFFSET_OF_FIELD(type, field) LOS_OFF_SET_OF(type, field) #define OFFSET_OF_FIELD(type, field) LOS_OFF_SET_OF(type, field)
/*这些宏的作用是帮助程序员在编写代码时可以方便地获取结构体成员的偏移量。
通常情况下，结构体成员的偏移量用于在程序中进行内存操作，
比如根据结构体的指针和成员的偏移量，
可以获取到该成员的地址或修改该成员的值。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Obtain the pointer to a structure that contains a doubly linked list. * @brief Obtain the pointer to a structure that contains a doubly linked list.
@ -347,12 +309,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE BOOL LOS_ListEmpty(LOS_DL_LIST *list)
for (item = LOS_DL_LIST_ENTRY((list)->pstNext, type, member); \ for (item = LOS_DL_LIST_ENTRY((list)->pstNext, type, member); \
&(item)->member != (list); \ &(item)->member != (list); \
item = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member)) item = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member))
/*宏的实现通过 for 循环来实现链表的遍历，具体步骤如下：
首先使用 LOS_DL_LIST_ENTRY 宏获取链表头部节点的指针，并将其赋值给 item 变量，从而初始化遍历的起始位置。
接着判断条件 &(item)->member != (list)，当遍历到链表末尾时，即链表头部时结束遍历，否则继续循环。
在循环体内，执行对当前节点的操作，并使用 LOS_DL_LIST_ENTRY 宏获取下一个节点的指针，从而实现链表的顺序遍历。
通过这些步骤，可以方便地遍历双向链表中的每个节点，并对每个节点执行相应的操作。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Traverse a doubly linked list which is included in a given type structure. And * @brief Traverse a doubly linked list which is included in a given type structure. And
@ -386,13 +343,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE BOOL LOS_ListEmpty(LOS_DL_LIST *list)
next = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member); \ next = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member); \
&(item)->member != (list); \ &(item)->member != (list); \
item = next, next = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member)) item = next, next = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member))
/*该宏的功能是按顺序遍历链表中的每个节点，并对每个节点执行指定的操作。其参数包括：
item：表示当前遍历到的节点
next：表示下一个节点的指针
list：表示链表的头部
type：表示链表节点所在的结构体类型
member：表示链表节点在结构体中的成员名*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Iterate over a doubly linked list of given type, and call hook for any extra procedures every time. * @brief Iterate over a doubly linked list of given type, and call hook for any extra procedures every time.
@ -419,13 +370,7 @@ member
for (item = LOS_DL_LIST_ENTRY((list)->pstNext, type, member), hook; \ for (item = LOS_DL_LIST_ENTRY((list)->pstNext, type, member), hook; \
&(item)->member != (list); \ &(item)->member != (list); \
item = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member), hook) item = LOS_DL_LIST_ENTRY((item)->member.pstNext, type, member), hook)
/*该宏的功能是按顺序遍历链表中的每个节点，并在每个节点遍历之前执行指定的钩子函数。其参数包括：
item：表示当前遍历到的节点
list：表示链表的头部
type：表示链表节点所在的结构体类型
member：表示链表节点在结构体中的成员名
hook：表示要执行的钩子函数*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Delete a specified node from a doubly linked list and reinitialize the node. * @brief Delete a specified node from a doubly linked list and reinitialize the node.
@ -451,7 +396,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListDelInit(LOS_DL_LIST *list)
list->pstPrev->pstNext = list->pstNext; list->pstPrev->pstNext = list->pstNext;
LOS_ListInit(list); LOS_ListInit(list);
} }
/**/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Traverse a doubly linked list. * @brief Traverse a doubly linked list.
@ -478,12 +423,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListDelInit(LOS_DL_LIST *list)
for (item = (list)->pstNext; \ for (item = (list)->pstNext; \
(item) != (list); \ (item) != (list); \
item = (item)->pstNext) item = (item)->pstNext)
/*宏的实现通过 for 循环来实现链表的遍历，具体步骤如下：
在循环初始化部分，将 item 初始化为链表头部节点的下一个节点，即 (list)->pstNext。
在循环条件中，判断条件 (item) != (list)，当 item 等于链表头部时，即遍历到链表末尾时结束遍历，否则继续循环。
在每次循环结束之后，将 item 更新为下一个节点的指针，即 (item)->pstNext。
通过这些步骤，可以方便地遍历双向链表中的每个节点，并在循环体内对每个节点执行指定的操作。*/
/** /**
* @ingroup los_list * @ingroup los_list
* @brief Traverse a doubly linked list safe against removal of list entry. * @brief Traverse a doubly linked list safe against removal of list entry.
@ -535,7 +475,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_ListDelInit(LOS_DL_LIST *list)
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
#define LOS_DL_LIST_HEAD(list) LOS_DL_LIST list = { &(list), &(list) } #define LOS_DL_LIST_HEAD(list) LOS_DL_LIST list = { &(list), &(list) }
/*通过这个宏，可以方便地定义和初始化一个双向链表的头部节点，为链表的后续操作提供了便利。*/
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
} }

14
src/kernel/include/los_lms.h
Unescape View File

@ -51,30 +51,18 @@ extern "C" {
#define memmove_s KasanMemmoveSec #define memmove_s KasanMemmoveSec
#define strcat_s KasanStrcatSec #define strcat_s KasanStrcatSec
#define strcpy_s KasanStrcpySec #define strcpy_s KasanStrcpySec
/*使用#define预处理指令来重新定义标准库函数的名称。这种技术通常用于调试或测试目的，或者提供这些函数的自定义实现。
代码片段中，函数memcpy、memmove、strcat和strcpy被重新定义为KasanMemcpy、
KasanMemmove、KasanStrcat和KasanStrcpy。类似地，memcpy_s、memmove_s、strcat_s和strcpy_s
被重新定义为KasanMemcpySec、KasanMemmoveSec、KasanStrcatSec和KasanStrcpySec。*/
// End: Kernel Address Sanitizer(KASAN) for LiteOS // End: Kernel Address Sanitizer(KASAN) for LiteOS
VOID *KasanMemcpy(VOID *__restrict dest, const VOID *__restrict src, size_t copyAmount); VOID *KasanMemcpy(VOID *__restrict dest, const VOID *__restrict src, size_t copyAmount);
VOID *KasanMemmove(VOID *dest, const VOID *src, size_t len); VOID *KasanMemmove(VOID *dest, const VOID *src, size_t len);
CHAR *KasanStrcat(CHAR *s, const CHAR *append); CHAR *KasanStrcat(CHAR *s, const CHAR *append);
CHAR *KasanStrcpy(CHAR *dest, const CHAR *src); CHAR *KasanStrcpy(CHAR *dest, const CHAR *src);
/*KasanMemcpy：类似于标准库中的memcpy，用于在内存中复制一定数量的数据。可能会包含额外的内存访问检查。
KasanMemmove：类似于标准库中的memmove，用于在内存中移动一定数量的数据。同样可能包含额外的内存访问检查。
KasanStrcat：类似于标准库中的strcat，用于将一个字符串附加到另一个字符串的末尾。可能包含额外的内存访问检查。
KasanStrcpy：类似于标准库中的strcpy，用于将一个字符串复制到另一个字符串。同样可能包含额外的内存访问检查。*/
errno_t KasanMemcpySec(VOID *dest, size_t destMax, const VOID *src, size_t copyAmount); errno_t KasanMemcpySec(VOID *dest, size_t destMax, const VOID *src, size_t copyAmount);
errno_t KasanMemmoveSec(VOID *dest, size_t destMax, const VOID *src, size_t len); errno_t KasanMemmoveSec(VOID *dest, size_t destMax, const VOID *src, size_t len);
errno_t KasanStrcatSec(CHAR *s, size_t destMax, const CHAR *append); errno_t KasanStrcatSec(CHAR *s, size_t destMax, const CHAR *append);
errno_t KasanStrcpySec(CHAR *dest, size_t destMax, const CHAR *src); errno_t KasanStrcpySec(CHAR *dest, size_t destMax, const CHAR *src);
/*主要是用于处理字符串和内存拷贝操作。这里的 destMax 参数通常表示目标缓冲区的最大长度，以防止缓冲区溢出等安全问题。
KasanMemcpySec：类似于标准库中的memcpy，用于在内存中复制一定数量的数据。增加了目标缓冲区大小的参数，以保证不会发生缓冲区溢出。
KasanMemmoveSec：类似于标准库中的memmove，用于在内存中移动一定数量的数据。同样增加了目标缓冲区大小的参数。
KasanStrcatSec：类似于标准库中的strcat，用于将一个字符串附加到另一个字符串的末尾。增加了目标缓冲区大小的参数，以保证不会发生缓冲区溢出。
KasanStrcpySec：类似于标准库中的strcpy，用于将一个字符串复制到另一个字符串。同样增加了目标缓冲区大小的参数。*/
#endif /* LOSCFG_KERNEL_LMS */ #endif /* LOSCFG_KERNEL_LMS */
#ifdef __cplusplus #ifdef __cplusplus

23
src/kernel/include/los_lockdep.h
Unescape View File

@ -55,33 +55,20 @@ enum LockDepErrType {
/* overflow, needs expand */ /* overflow, needs expand */
LOCKDEP_ERR_OVERFLOW, LOCKDEP_ERR_OVERFLOW,
}; };
/*这是一个枚举类型 LockDepErrType，用于表示在锁依赖性检查中可能发生的不同错误类型。下面是该枚举类型定义的各个取值及其含义：
LOCKDEP_SUCCESS：锁依赖性检查成功，没有发现错误。
LOCKDEP_ERR_DOUBLE_LOCK：发现了重复加锁的错误。表示在某个线程中多次对同一把锁进行了加锁操作。
LOCKDEP_ERR_DEAD_LOCK：发现了死锁的错误。表示在不同线程之间存在循环的锁依赖关系，导致了死锁的发生。
LOCKDEP_ERR_UNLOCK_WITHOUT_LOCK：发现了未解锁的错误。表示在某个线程中出现了解锁操作，但该线程之前并未对对应的锁进行过加锁操作。
LOCKDEP_ERR_OVERFLOW：溢出错误。表示枚举类型需要扩展，因为当前定义的取值已经无法满足需求。*/
typedef struct { typedef struct {
VOID *lockPtr; VOID *lockPtr;
VOID *lockAddr; VOID *lockAddr;
UINT64 waitTime; UINT64 waitTime;
UINT64 holdTime; UINT64 holdTime;
} HeldLocks; } HeldLocks;
/*这个结构体主要用于在锁依赖性分析和调试过程中记录当前线程持有的锁的相关信息。通过记录这些信息，
可以对锁的使用情况进行监控和分析，以便发现潜在的死锁、竞争条件等问题。
lockPtr：表示持有的锁的指针。它是一个 VOID* 类型的指针，通常用于指向被持有的锁的内存地址。
lockAddr：表示持有的锁的地址。它是一个 VOID* 类型的指针，通常用于指向锁对象的内存地址。
waitTime：表示等待该锁的时间。它是一个 UINT64 类型的变量，通常表示在获取该锁之前，当前线程等待该锁的时间。
holdTime：表示持有该锁的时间。它是一个 UINT64 类型的变量，通常表示当前线程已经持有该锁的时间。*/
typedef struct { typedef struct {
VOID *waitLock; VOID *waitLock;
INT32 lockDepth; INT32 lockDepth;
HeldLocks heldLocks[MAX_LOCK_DEPTH]; HeldLocks heldLocks[MAX_LOCK_DEPTH];
} LockDep; } LockDep;
/*这个结构体主要用于在锁依赖性分析和调试过程中记录当前线程的锁依赖关系。
通过记录当前线程正在等待的锁、持有的锁的深度以及每个层次的锁的详细信息，
可以对锁的使用情况进行监控和分析，以便发现潜在的死锁、竞争条件等问题。*/
/** /**
* @ingroup los_lockdep * @ingroup los_lockdep
* *
@ -101,8 +88,7 @@ typedef struct {
* @since Huawei LiteOS V200R003C00 * @since Huawei LiteOS V200R003C00
*/ */
extern VOID OsLockDepCheckIn(const SPIN_LOCK_S *lock); extern VOID OsLockDepCheckIn(const SPIN_LOCK_S *lock);
/*函数名称为 OsLockDepCheckIn，参数类型为 const SPIN_LOCK_S* lock，返回类型为 VOID。该函数的作用是将指定
的自旋锁 lock 添加到锁依赖性检查中，用于进行锁依赖性的分析和调试。*/
/** /**
* @ingroup los_lockdep * @ingroup los_lockdep
* *
@ -142,8 +128,7 @@ extern VOID OsLockDepRecord(SPIN_LOCK_S *lock);
* @since Huawei LiteOS V200R003C00 * @since Huawei LiteOS V200R003C00
*/ */
extern VOID OsLockDepCheckOut(SPIN_LOCK_S *lock); extern VOID OsLockDepCheckOut(SPIN_LOCK_S *lock);
/*函数名称为 OsLockDepCheckOut，参数类型为 SPIN_LOCK_S* lock，返回类型为 VOID。该函数的作用
是从锁依赖性检查中移除指定的自旋锁 lock，用于结束对该锁的依赖性分析和调试。*/
/** /**
* @ingroup los_lockdep * @ingroup los_lockdep
* *

64
src/kernel/include/los_lowpower.h
Unescape View File

@ -57,14 +57,7 @@ typedef enum LOS_INTERMIT_MODE {
LOS_INTERMIT_SHUTDOWN, /**< Shutdown mode */ LOS_INTERMIT_SHUTDOWN, /**< Shutdown mode */
LOS_INTERMIT_MAX, LOS_INTERMIT_MAX,
} LosIntermitMode; } LosIntermitMode;
/*这是一个枚举类型 LOS_INTERMIT_MODE 的定义，包含了几个枚举常量：
LOS_INTERMIT_NONE：表示没有中断模式
LOS_INTERMIT_LIGHT_SLEEP：表示轻度睡眠模式
LOS_INTERMIT_DEEP_SLEEP：表示深度睡眠模式
LOS_INTERMIT_STANDBY：表示待机模式
LOS_INTERMIT_SHUTDOWN：表示关机模式
LOS_INTERMIT_MAX：该枚举类型的最大值，用于辅助枚举类型的范围检查*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* *
@ -77,13 +70,7 @@ typedef enum LOS_FREQ_MODE {
LOS_SYS_FREQ_LOW, /**< Low freq */ LOS_SYS_FREQ_LOW, /**< Low freq */
LOS_SYS_FREQ_MAX, LOS_SYS_FREQ_MAX,
} LosFreqMode; } LosFreqMode;
/*这是另一个枚举类型 LOS_FREQ_MODE 的定义，包含了几个枚举常量：
LOS_SYS_FREQ_SUPER：表示超高频模式
LOS_SYS_FREQ_HIGH：表示高频模式
LOS_SYS_FREQ_NORMAL：表示正常频率模式
LOS_SYS_FREQ_LOW：表示低频模式
LOS_SYS_FREQ_MAX：该枚举类型的最大值，用于辅助枚举类型的范围检查*/
typedef UINT32 (*LowpowerExternalVoterHandle)(VOID); typedef UINT32 (*LowpowerExternalVoterHandle)(VOID);
STATIC INLINE BOOL FreqHigher(LosFreqMode freq1, LosFreqMode freq2) STATIC INLINE BOOL FreqHigher(LosFreqMode freq1, LosFreqMode freq2)
@ -109,19 +96,7 @@ typedef struct {
UINT32 (*getSleepMode)(VOID); /**< Get sleep mode interface, the retval type is LosIntermitMode */ UINT32 (*getSleepMode)(VOID); /**< Get sleep mode interface, the retval type is LosIntermitMode */
VOID (*setSleepMode)(UINT32 mode); /**< Set sleep mode interface, the param type is LosIntermitMode */ VOID (*setSleepMode)(UINT32 mode); /**< Set sleep mode interface, the param type is LosIntermitMode */
} PowerMgrOps; } PowerMgrOps;
/*这是一个结构体类型 PowerMgrOps 的定义，包含了多个函数指针成员：
process：电源管理框架的入口接口
wakeupFromReset：从镜像中唤醒的恢复接口
resumeFromInterrupt：从中断中唤醒的恢复接口
changeFreq：系统频率调节接口，参数为 LosFreqMode
deepSleepVoteBegin：深度睡眠投票标记接口
deepSleepVoteEnd：深度睡眠投票取消接口
deepSleepVoteDelay：深度睡眠投票延迟接口，参数为延迟的时钟周期数
registerExternalVoter：注册外部投票者接口，参数为一个函数指针，返回值为 UINT32
getDeepSleepVoteCount：获取深度睡眠投票计数接口，返回 UINT32
getSleepMode：获取睡眠模式接口，返回值类型为 LosIntermitMode
setSleepMode：设置睡眠模式接口，参数类型为 UINT32，表示 LosIntermitMode*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief System main frequency tuning. * @brief System main frequency tuning.
@ -140,9 +115,7 @@ setSleepMode
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
extern VOID LOS_PowerMgrChangeFreq(LosFreqMode freq); extern VOID LOS_PowerMgrChangeFreq(LosFreqMode freq);
/*这是一个外部声明（extern）的函数 LOS_PowerMgrChangeFreq，
它接受一个 LosFreqMode 类型的参数 freq，用于改变系统的工作频率。
根据函数名和参数类型来看，这个函数很可能是用于在系统中切换不同的工作频率模式。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Vote to enter deep sleep. * @brief Vote to enter deep sleep.
@ -180,8 +153,7 @@ extern VOID LOS_PowerMgrDeepSleepVoteBegin(VOID);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
extern VOID LOS_PowerMgrDeepSleepVoteEnd(VOID); extern VOID LOS_PowerMgrDeepSleepVoteEnd(VOID);
/*这是一个外部声明（extern）的函数 LOS_PowerMgrDeepSleepVoteEnd，它没有任何参数，返回类型为 VOID。根据函数名来看，
这个函数很可能用于结束深度睡眠投票，即取消之前进行的深度睡眠投票。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Sleep delay vote. * @brief Sleep delay vote.
@ -200,8 +172,7 @@ extern VOID LOS_PowerMgrDeepSleepVoteEnd(VOID);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
extern VOID LOS_PowerMgrSleepDelay(UINT32 tick); extern VOID LOS_PowerMgrSleepDelay(UINT32 tick);
/*这是一个外部声明（extern）的函数 LOS_PowerMgrSleepDelay，它接受一个 UINT32 类型的参数 tick，
用于在系统中设置睡眠延迟，即指定一定的时钟周期数作为睡眠延迟。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Register the external voter. * @brief Register the external voter.
@ -220,9 +191,7 @@ extern VOID LOS_PowerMgrSleepDelay(UINT32 tick);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
extern VOID LOS_PowerMgrRegisterExtVoter(UINT32 (*)(VOID)); extern VOID LOS_PowerMgrRegisterExtVoter(UINT32 (*)(VOID));
/*这是一个外部声明（extern）的函数 LOS_PowerMgrRegisterExtVoter，
它接受一个函数指针作为参数，该函数指针指向一个不接受任何参数并返回 UINT32 类型的函数。根据函数名来看，这个函数很可能用于注册外部投票者
，即将提供的函数指针注册为外部投票者的处理函数。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Get the sleep mode. * @brief Get the sleep mode.
@ -281,9 +250,7 @@ extern UINT32 LOS_PowerMgrGetDeepSleepVoteCount(VOID);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
extern VOID LOS_LowpowerInit(const PowerMgrOps *pmOps); extern VOID LOS_LowpowerInit(const PowerMgrOps *pmOps);
/*这是一个外部声明（extern）的函数 LOS_LowpowerInit，
它接受一个 const PowerMgrOps * 类型的指针参数 pmOps，用于初始化低功耗模式下的系统。根据函数名来看，这个函数很可能是用于在系统启动时初始化与低功耗相关的操作和参数，
以便后续能够进入低功耗状态并正确恢复系统。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Define the lowpower framework process function type. * @brief Define the lowpower framework process function type.
@ -302,10 +269,7 @@ extern VOID LOS_LowpowerInit(const PowerMgrOps *pmOps);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
typedef VOID (*LowPowerHookFn)(VOID); typedef VOID (*LowPowerHookFn)(VOID);
/*这是一个类型定义语句，定义了一个名为 LowPowerHookFn 的函数指针类型。
该函数指针类型指向一个不接受任何参数并返回 VOID 的函数。
这种类型的函数指针通常用于注册低功耗模式下的钩子函数，
以便在进入或退出低功耗模式时执行特定的操作*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Register a hook to enter lowpower framework process. * @brief Register a hook to enter lowpower framework process.
@ -324,10 +288,7 @@ typedef VOID (*LowPowerHookFn)(VOID);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
extern VOID LOS_LowpowerHookReg(LowPowerHookFn hook); extern VOID LOS_LowpowerHookReg(LowPowerHookFn hook);
/*这是一个外部声明（extern）的函数 LOS_LowpowerHookReg，
它接受一个 LowPowerHookFn 类型的参数 hook，用于注册低功耗模式下的钩子函数。
根据函数名来看，这个函数很可能用于在系统中注册低功耗模式下的钩子函数，
以便在进入或退出低功耗模式时执行特定的操作。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Define the lowpower framework wakup function type. * @brief Define the lowpower framework wakup function type.
@ -346,10 +307,7 @@ extern VOID LOS_LowpowerHookReg(LowPowerHookFn hook);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
typedef VOID (*IntWakeupHookFn)(HWI_HANDLE_T hwiNum); typedef VOID (*IntWakeupHookFn)(HWI_HANDLE_T hwiNum);
/*这是一个类型定义语句，定义了一个名为 IntWakeupHookFn 的函数指针类型。
该函数指针类型指向一个接受 HWI_HANDLE_T 类型参数并返回 VOID 的函数。
这种类型的函数指针通常用于注册中断唤醒的钩子函数，以便在特定中断唤醒事件发生时执行特定的操作。
*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Register a hook to wakeup from interrupt. * @brief Register a hook to wakeup from interrupt.
@ -368,11 +326,7 @@ typedef VOID (*IntWakeupHookFn)(HWI_HANDLE_T hwiNum);
* @since Huawei LiteOS V200R005C10 * @since Huawei LiteOS V200R005C10
*/ */
extern VOID LOS_IntWakeupHookReg(IntWakeupHookFn hook); extern VOID LOS_IntWakeupHookReg(IntWakeupHookFn hook);
/*这是一个外部声明（extern）的函数 LOS_IntWakeupHookReg，
它接受一个 IntWakeupHookFn 类型的参数 hook，用于注册中断唤醒的钩子函数。
根据函数名来看，这个函数很可能用于在系统中注册中断唤醒的钩子函数，
以便在特定中断唤醒事件发生时执行特定的操作。
*/
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
} }

37
src/kernel/include/los_lowpower_impl.h
Unescape View File

@ -59,22 +59,7 @@ typedef struct {
UINT32 (*getSleepMode)(VOID); /**< Get sleep mode */ UINT32 (*getSleepMode)(VOID); /**< Get sleep mode */
VOID (*setSleepMode)(UINT32 mode); /**< Set sleep mode */ VOID (*setSleepMode)(UINT32 mode); /**< Set sleep mode */
} PowerMgrRunOps; } PowerMgrRunOps;
/*具体来说，该结构体包含以下函数指针成员：
changeFreq：调整系统频率。
enterLightSleep：进入轻度睡眠（light sleep）模式。
enterDeepSleep：进入深度睡眠（deep sleep）模式。
setWakeUpTimer：设置唤醒定时器。
withdrawWakeUpTimer：撤销唤醒定时器。
getSleepTime：获取睡眠时间。
selectSleepMode：选择进入睡眠模式的策略函数。
preConfig：提供特殊需要在进入睡眠前进行的预配置。
postConfig：提供特殊需要在唤醒后进行的后配置。
contextSave：保存上下文。
contextRestore：恢复上下文。
getDeepSleepVoteCount：获取深度睡眠投票计数。
getSleepMode：获取当前睡眠模式。
setSleepMode：设置睡眠模式。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* *
@ -85,11 +70,7 @@ typedef struct {
UINT32 minDeepSleepTicks; /**< Min deep sleep ticks */ UINT32 minDeepSleepTicks; /**< Min deep sleep ticks */
UINT32 maxDeepSleepTicks; /**< Max deep sleep ticks */ UINT32 maxDeepSleepTicks; /**< Max deep sleep ticks */
} PowerMgrConfig; } PowerMgrConfig;
/*minLightSleepTicks：最小轻度睡眠（light sleep）时钟周期数。
minDeepSleepTicks：最小深度睡眠（deep sleep）时钟周期数。
maxDeepSleepTicks：最大深度睡眠（deep sleep）时钟周期数。
这些成员变量可能用于配置功耗管理模块的相关参数，以控制系统进入不同级别的睡眠模式，
并限制最小和最大的睡眠时长。具体的含义和用法需要根据上下文和使用场景来确定。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* *
@ -107,16 +88,7 @@ typedef struct {
VOID (*otherCoreResume)(VOID); /**< Other core Resume for multi-core scenes */ VOID (*otherCoreResume)(VOID); /**< Other core Resume for multi-core scenes */
VOID (*resumeFromReset)(VOID); /**< Resume from image */ VOID (*resumeFromReset)(VOID); /**< Resume from image */
} PowerMgrDeepSleepOps; } PowerMgrDeepSleepOps;
/*couldDeepSleep：检查系统是否可以进入深度睡眠状态。
systemWakeup：唤醒系统。
suspendPreConfig：提供特殊需要在进入深度睡眠前进行的暂停预配置。
suspendDevice：进入深度睡眠前暂停设备。
rollback：如果进入深度睡眠失败，则回滚。
resumeDevice：从深度睡眠状态恢复后恢复设备。
resumePostConfig：提供特殊需要在从深度睡眠状态中恢复后进行的恢复后配置。
resumeCallBack：恢复回调。
otherCoreResume：多核场景下，其他核心的恢复方法。
resumeFromReset：从映像中恢复。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* *
@ -127,10 +99,7 @@ typedef struct {
PowerMgrDeepSleepOps deepSleepOps; /**< power manager deep sleep operations */ PowerMgrDeepSleepOps deepSleepOps; /**< power manager deep sleep operations */
PowerMgrConfig config; /**< power manager config */ PowerMgrConfig config; /**< power manager config */
} PowerMgrParameter; } PowerMgrParameter;
/*runOps：类型为 PowerMgrRunOps 的结构体变量，用于描述系统运行状态下的功耗管理操作集合。
deepSleepOps：类型为 PowerMgrDeepSleepOps 的结构体变量，用于描述系统进入深度睡眠状态下的功耗管理操作集合。
config：类型为 PowerMgrConfig 的结构体变量，用于配置功耗管理模块的相关参数，控制系统进入不同级别的睡眠模式。
通过将这些结构体变量组合到 PowerMgrParameter 结构体中，可以实现对系统运行状态和深度睡眠状态下的功耗管理操作进行统一管理和配置。*/
/** /**
* @ingroup los_lowpower * @ingroup los_lowpower
* @brief Init the power manager framework. * @brief Init the power manager framework.

29
src/kernel/include/los_membox.h
Unescape View File

@ -75,17 +75,7 @@ extern "C" {
* Head size of each node in staic memory pool * Head size of each node in staic memory pool
*/ */
#define OS_MEMBOX_NODE_HEAD_SIZE sizeof(LOS_MEMBOX_NODE) #define OS_MEMBOX_NODE_HEAD_SIZE sizeof(LOS_MEMBOX_NODE)
/*LOS_MEMBOX_ALLIGNED(memAddr) 宏用于对内存地址进行对齐操作。
它将 memAddr 强制转换为 UINTPTR 类型，然后加上 sizeof(UINTPTR) -
1，再进行按位取反操作，最后与 ~(sizeof(UINTPTR) - 1) 进行按位与运算。
这样可以确保地址按照 sizeof(UINTPTR) 字节对齐。
OS_MEMBOX_NEXT(addr, blkSize) 宏用于获取静态内存池中下一个节点的地址。
它将 addr 强制转换为 UINT8* 类型，然后加上 blkSize，得到下一个节点的地址。
OS_MEMBOX_NODE_HEAD_SIZE 宏定义了静态内存池中每个节点的头部大小，即 LOS_MEMBOX_NODE 的大小。
这些宏在静态内存池的实现中起到了辅助作用，用于计算和管理内存节点的地址和大小。*/
/** /**
* @ingroup los_membox * @ingroup los_membox
* @brief Obtain the size of the static memory pool. * @brief Obtain the size of the static memory pool.
@ -108,10 +98,7 @@ OS_MEMBOX_NODE_HEAD_SIZE
*/ */
#define LOS_MEMBOX_SIZE(blkSize, blkNum) \ #define LOS_MEMBOX_SIZE(blkSize, blkNum) \
(sizeof(LOS_MEMBOX_INFO) + (LOS_MEMBOX_ALLIGNED((blkSize) + OS_MEMBOX_NODE_HEAD_SIZE) * (blkNum))) (sizeof(LOS_MEMBOX_INFO) + (LOS_MEMBOX_ALLIGNED((blkSize) + OS_MEMBOX_NODE_HEAD_SIZE) * (blkNum)))
/*该宏首先使用 LOS_MEMBOX_ALLIGNED 宏对 (blkSize) + OS_MEMBOX_NODE_HEAD_SIZE 进行对齐操作，确保每个内存块都按照节点大小对齐。然后将对齐后的大小乘以 blkNum，并加上 sizeof(LOS_MEMBOX_INFO)，得到静态内存池的总大小。
其中，sizeof(LOS_MEMBOX_INFO) 表示静态内存池的元信息（头部）大小，
包括内存池起始地址、内存块大小、内存块数量等信息。*/
/** /**
* @ingroup los_membox * @ingroup los_membox
* Structure of a free node in a static memory pool * Structure of a free node in a static memory pool
@ -137,11 +124,7 @@ typedef struct {
} LOS_MEMBOX_INFO; } LOS_MEMBOX_INFO;
typedef LOS_MEMBOX_INFO OS_MEMBOX_S; typedef LOS_MEMBOX_INFO OS_MEMBOX_S;
/*LOS_MEMBOX_INFO：静态内存池的元信息结构体。包含了静态内存池的起始地址、
内存块大小、内存块数量等信息。同时还包含了 uwBlkCnt 记录已分配内存块数量的成员变量
和 stFreeList 用于记录空闲内存块的链表（仅在 LOSCFG_KERNEL_MEMBOX_STATIC 宏定义时可用）。
OS_MEMBOX_S：与 LOS_MEMBOX_INFO 结构体等价的别名。*/
/** /**
* @ingroup los_membox * @ingroup los_membox
* @brief Initialize a static memory pool. * @brief Initialize a static memory pool.
@ -170,8 +153,7 @@ OS_MEMBOX_S
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MemboxInit(VOID *pool, UINT32 poolSize, UINT32 blkSize); extern UINT32 LOS_MemboxInit(VOID *pool, UINT32 poolSize, UINT32 blkSize);
/*该函数会使用提供的内存池起始地址和大小来初始化静态内存池，并指定每个内存块的大小。
在初始化完成后，该内存池将可以被用于分配内存块。*/
/** /**
* @ingroup los_membox * @ingroup los_membox
* @brief Request a static memory block. * @brief Request a static memory block.
@ -220,7 +202,7 @@ extern VOID *LOS_MemboxAlloc(VOID *pool);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MemboxFree(VOID *pool, VOID *box); extern UINT32 LOS_MemboxFree(VOID *pool, VOID *box);
/*调用该函数将会释放 box 所指向的内存块，并将其重新加入到内存池的空闲内存块链表中，以便下次分配使用。*/
/** /**
* @ingroup los_membox * @ingroup los_membox
* @brief Clear a static memory block. * @brief Clear a static memory block.
@ -244,8 +226,7 @@ extern UINT32 LOS_MemboxFree(VOID *pool, VOID *box);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID LOS_MemboxClr(VOID *pool, VOID *box); extern VOID LOS_MemboxClr(VOID *pool, VOID *box);
/*调用该函数将会将 box 所指向的内存块的数据内容清零，使其变为初始状态。
该函数通常用于在重新使用内存块之前清除其中的旧数据，以免对后续操作产生影响。*/
/** /**
* @ingroup los_membox * @ingroup los_membox
* @brief show static memory pool information. * @brief show static memory pool information.
@ -296,9 +277,7 @@ extern VOID LOS_ShowBox(VOID *pool);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MemboxStatisticsGet(const VOID *boxMem, UINT32 *maxBlk, UINT32 *blkCnt, UINT32 *blkSize); extern UINT32 LOS_MemboxStatisticsGet(const VOID *boxMem, UINT32 *maxBlk, UINT32 *blkCnt, UINT32 *blkSize);
/*调用该函数将会获取静态内存池的统计信息，包括最大可分配内存块数量、
已分配内存块数量以及每个内存块的大小，并通过传入的指针参数返回给调用者。
这些统计信息可以用于监控和调试内存池的使用情况。*/
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
} }

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

@ -155,12 +155,7 @@ extern UINTPTR g_excInteractMemSize;
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID *LOS_MemMalloc(VOID *pool, UINT32 size, UINT32 moduleId); extern VOID *LOS_MemMalloc(VOID *pool, UINT32 size, UINT32 moduleId);
/*pool：指向内存池起始地址的指针。
size：要分配的内存块大小。
moduleId：分配内存块所属的模块 ID。
调用该函数将会在指定的内存池中分配大小为 size 的内存块，并将其地址返回给调用者。
若内存池中无法分配足够的内存块，则返回 NULL 指针表示分配失败。
分配的内存块所属的模块 ID 由 moduleId 参数指定，通常用于管理内存使用情况。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Allocate aligned memory. * @brief Allocate aligned memory.
@ -190,10 +185,7 @@ moduleId
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID *LOS_MemMallocAlign(VOID *pool, UINT32 size, UINT32 boundary, UINT32 moduleId); extern VOID *LOS_MemMallocAlign(VOID *pool, UINT32 size, UINT32 boundary, UINT32 moduleId);
/*调用该函数将会在指定的内存池中按照指定的对齐边界（boundary）分配大小为 size 的内存块，并将其地址返回给调用者。
对齐边界表示内存块起始地址相对于内存池起始地址的偏移量必须是 boundary 的倍数。
若内存池中无法分配足够的对齐内存块，则返回 NULL 指针表示分配失败。
分配的内存块所属的模块 ID 由 moduleId 参数指定，通常用于管理内存使用情况。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Free dynamic memory. * @brief Free dynamic memory.
@ -220,9 +212,7 @@ extern VOID *LOS_MemMallocAlign(VOID *pool, UINT32 size, UINT32 boundary, UINT32
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MemMfree(VOID *pool, VOID *ptr, UINT32 moduleId); extern UINT32 LOS_MemMfree(VOID *pool, VOID *ptr, UINT32 moduleId);
/*调用该函数将会释放由 ptr 指向的内存块，并将其归还给指定的内存池。同时，通过 moduleId 参数指定要释放的内存块所属的模块 ID，以便进行相关的内存管理操作。
在调用该函数之前，需要确保要释放的内存块确实是之前通过 LOS_MemMalloc 或 LOS_MemMallocAlign 分配得到的，并且未被重复释放。否则可能会导致内存管理错误和程序异常行为。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Re-allocate a memory block. * @brief Re-allocate a memory block.
@ -334,14 +324,7 @@ typedef struct {
UINT32 uwUsageWaterLine; /**< this structure member is defined only when LOSCFG_MEM_TASK_STAT is defined. */ UINT32 uwUsageWaterLine; /**< this structure member is defined only when LOSCFG_MEM_TASK_STAT is defined. */
#endif #endif
} LOS_MEM_POOL_STATUS; } LOS_MEM_POOL_STATUS;
/*uwTotalUsedSize：内存池中已使用的总大小（单位：字节）。
uwTotalFreeSize：内存池中未使用的总大小（单位：字节）。
uwMaxFreeNodeSize：内存池中最大的可用内存块大小（单位：字节）。
uwUsedNodeNum：内存池中已使用的内存块数量。
uwFreeNodeNum：内存池中未使用的内存块数量。
uwUsageWaterLine（仅在 LOSCFG_MEM_TASK_STAT 定义时有效）：内存池的使用水位线，表示内存池在运行过程中达到的最高使用量。
通过使用该结构体，可以获取内存池的详细状态信息，例如已使用的总大小、未使用的总大小、可用的最大内存块大小以及相关的内存块数量。
其中，如果定义了 LOSCFG_MEM_TASK_STAT，还可以获取内存池的使用水位线。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Initialize dynamic memory. * @brief Initialize dynamic memory.
@ -370,8 +353,7 @@ uwUsageWaterLine
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MemInit(VOID *pool, UINT32 size); extern UINT32 LOS_MemInit(VOID *pool, UINT32 size);
/*调用该函数将会对指定的内存池进行初始化操作，使其具备可用于分配和管理内存块的能力。
在初始化完成后，该内存池可以被用于动态分配和释放内存块。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Allocate dynamic memory. * @brief Allocate dynamic memory.
@ -398,8 +380,7 @@ extern UINT32 LOS_MemInit(VOID *pool, UINT32 size);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID *LOS_MemAlloc(VOID *pool, UINT32 size); extern VOID *LOS_MemAlloc(VOID *pool, UINT32 size);
/*通过该函数可以动态地从内存池中获取一块指定大小的内存块，以满足程序运行时的内存需求。分配的内存块可以根据实际需要进行读写操作
，并在不再需要时通过相应的内存释放函数进行释放和回收。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Free dynamic memory. * @brief Free dynamic memory.
@ -463,7 +444,7 @@ extern UINT32 LOS_MemFree(VOID *pool, VOID *ptr);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID *LOS_MemRealloc(VOID *pool, VOID *ptr, UINT32 size); extern VOID *LOS_MemRealloc(VOID *pool, VOID *ptr, UINT32 size);
//通过该函数可以动态地调整已分配内存块的大小，以满足程序运行时动态变化的内存需求。
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Allocate aligned memory. * @brief Allocate aligned memory.
@ -491,9 +472,7 @@ extern VOID *LOS_MemRealloc(VOID *pool, VOID *ptr, UINT32 size);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID *LOS_MemAllocAlign(VOID *pool, UINT32 size, UINT32 boundary); extern VOID *LOS_MemAllocAlign(VOID *pool, UINT32 size, UINT32 boundary);
/*通过该函数可以动态地从内存池中获取一块指定大小并满足对齐要求的内存块，
以满足程序运行时的内存需求。分配的内存块可以根据实际需要进行读写操作，
并在不再需要时通过相应的内存释放函数进行释放和回收。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Get the size of memory pool's size. * @brief Get the size of memory pool's size.
@ -634,9 +613,7 @@ extern UINTPTR LOS_MemLastUsedGet(VOID *pool);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MemInfoGet(VOID *pool, LOS_MEM_POOL_STATUS *poolStatus); extern UINT32 LOS_MemInfoGet(VOID *pool, LOS_MEM_POOL_STATUS *poolStatus);
/*调用该函数将会获取指定内存池的状态信息，并将其保存到指定的 LOS_MEM_POOL_STATUS 结构体中。如果获取成功，返回 LOS_OK；否则返回错误码。
通过该函数可以获取当前内存池的总容量、已使用的容量、剩余的容量等信息，以便于进行内存管理和优化。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Get the number of free node in every size. * @brief Get the number of free node in every size.
@ -681,10 +658,6 @@ extern UINT32 LOS_MemFreeNodeShow(VOID *pool);
extern UINT32 LOS_MemIntegrityCheck(VOID *pool); extern UINT32 LOS_MemIntegrityCheck(VOID *pool);
#ifdef LOSCFG_BASE_MEM_NODE_SIZE_CHECK #ifdef LOSCFG_BASE_MEM_NODE_SIZE_CHECK
/*调用该函数将会对指定的内存池进行完整性检查，以确保内存池中分配的内存块没有损坏或越界等问题。如果检查通过，返回 LOS_OK；否则返回错误码。
在代码中还有一个条件编译的宏定义 #ifdef LOSCFG_BASE_MEM_NODE_SIZE_CHECK，用于判断是否开启了基于内存节点大小的检查。如果该宏定义存在且为真，
则执行相应的代码逻辑；否则忽略该部分代码。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Check the size of the specified memory node. * @brief Check the size of the specified memory node.
@ -717,9 +690,7 @@ extern UINT32 LOS_MemIntegrityCheck(VOID *pool);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MemNodeSizeCheck(VOID *pool, VOID *ptr, UINT32 *totalSize, UINT32 *availSize); extern UINT32 LOS_MemNodeSizeCheck(VOID *pool, VOID *ptr, UINT32 *totalSize, UINT32 *availSize);
/*调用该函数将会检查指定内存池中给定内存节点的大小，并将总大小和可用大小分别保存到指定的变量中。如果检查成功，返回 LOS_OK；否则返回错误码。
使用该函数可以获得指定内存节点的总大小和可用大小信息。这对于动态管理内存节点、调试内存分配问题以及优化内存使用非常有用。*/
/** /**
* @ingroup los_memory * @ingroup los_memory
* @brief Set the memory check level. * @brief Set the memory check level.

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

@ -54,10 +54,7 @@ extern "C" {
* Solution: Decrease the number of mutexes defined by LOSCFG_BASE_IPC_MUX_LIMIT. * Solution: Decrease the number of mutexes defined by LOSCFG_BASE_IPC_MUX_LIMIT.
*/ */
#define LOS_ERRNO_MUX_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x00) #define LOS_ERRNO_MUX_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x00)
/*这段代码定义了一个名为 LOS_ERRNO_MUX_NO_MEMORY 的宏，用于表示互斥锁分配内存失败的错误码。
LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，
0x00 是该错误码在该模块中的具体数值。*/
/** /**
* @ingroup los_mux * @ingroup los_mux
* Mutex error code: The mutex is not usable. * Mutex error code: The mutex is not usable.
@ -67,7 +64,7 @@ LOS_ERRNO_OS_ERROR
* Solution: Check whether the mutex ID and the mutex state are applicable for the current operation. * Solution: Check whether the mutex ID and the mutex state are applicable for the current operation.
*/ */
#define LOS_ERRNO_MUX_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x01) #define LOS_ERRNO_MUX_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x01)
//LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，0x01 是该错误码在该模块中的具体数值。
/** /**
* @ingroup los_mux * @ingroup los_mux
* Mutex error code: Null pointer. * Mutex error code: Null pointer.
@ -77,8 +74,7 @@ LOS_ERRNO_OS_ERROR
* Solution: Check whether the input parameter is usable. * Solution: Check whether the input parameter is usable.
*/ */
#define LOS_ERRNO_MUX_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x02) #define LOS_ERRNO_MUX_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x02)
//这段代码定义了一个名为 LOS_ERRNO_MUX_PTR_NULL 的宏，用于表示互斥锁指针为空的错误码。
//LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，0x02 是该错误码在该模块中的具体数值。
/** /**
* @ingroup los_mux * @ingroup los_mux
* Mutex error code: No mutex is available and the mutex request fails. * Mutex error code: No mutex is available and the mutex request fails.
@ -88,9 +84,7 @@ LOS_ERRNO_OS_ERROR
* Solution: Increase the number of mutexes defined by LOSCFG_BASE_IPC_MUX_LIMIT. * Solution: Increase the number of mutexes defined by LOSCFG_BASE_IPC_MUX_LIMIT.
*/ */
#define LOS_ERRNO_MUX_ALL_BUSY LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x03) #define LOS_ERRNO_MUX_ALL_BUSY LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x03)
/*这段代码定义了一个名为 LOS_ERRNO_MUX_ALL_BUSY 的宏，用于表示互斥锁已全部被占用的错误码。
LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，0x03 是该错误码在该模块中的具体数值。*/
/** /**
* @ingroup los_mux * @ingroup los_mux
* Mutex error code: The mutex fails to be locked in non-blocking mode because it is locked by another thread. * Mutex error code: The mutex fails to be locked in non-blocking mode because it is locked by another thread.
@ -100,9 +94,7 @@ LOS_ERRNO_OS_ERROR
* Solution: Lock the mutex after it is unlocked by the thread that owns it, or set a waiting time. * Solution: Lock the mutex after it is unlocked by the thread that owns it, or set a waiting time.
*/ */
#define LOS_ERRNO_MUX_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x04) #define LOS_ERRNO_MUX_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x04)
/*这段代码定义了一个名为 LOS_ERRNO_MUX_UNAVAILABLE 的宏，用于表示互斥锁不可用的错误码。
LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，0x04 是该错误码在该模块中的具体数值。*/
/** /**
* @ingroup los_mux * @ingroup los_mux
* Mutex error code: The mutex is being locked during an interrupt. * Mutex error code: The mutex is being locked during an interrupt.
@ -112,9 +104,7 @@ LOS_ERRNO_OS_ERROR
* Solution: Check whether the mutex is being locked during an interrupt. * Solution: Check whether the mutex is being locked during an interrupt.
*/ */
#define LOS_ERRNO_MUX_PEND_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x05) #define LOS_ERRNO_MUX_PEND_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x05)
/*这段代码定义了一个名为 LOS_ERRNO_MUX_PEND_INTERR 的宏，用于表示互斥锁等待被阻塞时发生中断错误的错误码。
LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，0x05 是该错误码在该模块中的具体数值。*/
/** /**
* @ingroup los_mux * @ingroup los_mux
* Mutex error code: A thread locks a mutex after waiting for the mutex to be unlocked by another thread * Mutex error code: A thread locks a mutex after waiting for the mutex to be unlocked by another thread
@ -126,9 +116,7 @@ LOS_ERRNO_OS_ERROR
* thread will not wait for the mutex to become available. * thread will not wait for the mutex to become available.
*/ */
#define LOS_ERRNO_MUX_PEND_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x06) #define LOS_ERRNO_MUX_PEND_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x06)
/*这段代码定义了一个名为 LOS_ERRNO_MUX_PEND_IN_LOCK 的宏，用于表示在互斥锁上等待时发生死锁错误的错误码。
LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，0x06 是该错误码在该模块中的具体数值。*/
/** /**
* @ingroup los_mux * @ingroup los_mux
* Mutex error code: The mutex locking times out. * Mutex error code: The mutex locking times out.
@ -138,7 +126,7 @@ LOS_ERRNO_OS_ERROR
* Solution: Increase the waiting time or set the waiting time to LOS_WAIT_FOREVER (forever-blocking mode). * Solution: Increase the waiting time or set the waiting time to LOS_WAIT_FOREVER (forever-blocking mode).
*/ */
#define LOS_ERRNO_MUX_TIMEOUT LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x07) #define LOS_ERRNO_MUX_TIMEOUT LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x07)
//LOS_ERRNO_OS_ERROR 是一个宏，用于生成具有模块和错误码的错误码值。在这里，LOS_MOD_MUX 表示错误所属的模块是互斥锁模块，0x07 是该错误码在该模块中的具体数值。
/** /**
* @ingroup los_mux * @ingroup los_mux
* The error code is not in use temporarily. * The error code is not in use temporarily.
@ -187,9 +175,7 @@ LOS_ERRNO_OS_ERROR
* @deprecated This error code is obsolete since LiteOS 5.0.0. * @deprecated This error code is obsolete since LiteOS 5.0.0.
*/ */
#define LOS_ERRNO_MUX_PEND_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x0C) #define LOS_ERRNO_MUX_PEND_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_MUX, 0x0C)
/*其中 LOS_ERRNO_OS_ERROR 是一个宏函数，用于生成错误码。该宏函数接受两个参数：模块号和错误码。在这里，模块号为 LOS_MOD_MUX，错误码为 0x0C。
通过这个宏定义，可以方便地识别并处理在系统任务中使用互斥信号量时发生的错误情况。*/
/** /**
* @ingroup los_mux * @ingroup los_mux
* @brief Create a mutex. * @brief Create a mutex.
@ -275,14 +261,7 @@ extern UINT32 LOS_MuxDelete(UINT32 muxHandle);
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout); extern UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout);
/*参数说明：
muxHandle：互斥信号量句柄，即互斥信号量创建成功后返回的值。
timeout：等待互斥信号量的超时时间，单位为系统时钟节拍。如果设置为0，则表示永久等待。
返回值说明：
返回 LOS_OK 表示成功获取互斥信号量。
返回错误码表示获取互斥信号量失败，可能是由于传入的参数无效或者超时等原因导致。*/
/** /**
* @ingroup los_mux * @ingroup los_mux
* @brief Release a mutex. * @brief Release a mutex.

57
src/kernel/include/los_perf.h
Unescape View File

@ -75,12 +75,7 @@ enum PerfStatus {
PERF_STARTED, /**< perf is started */ PERF_STARTED, /**< perf is started */
PERF_STOPED, /**< perf is stopped */ PERF_STOPED, /**< perf is stopped */
}; };
/*枚举类型 PerfStatus 包含了三个枚举常量：
PERF_UNINIT：表示性能监控未初始化的状态。
PERF_STARTED：表示性能监控已经开始的状态。
PERF_STOPED：表示性能监控已经停止的状态。
通过使用这个枚举类型，可以方便地表示和判断性能监控的当前状态。*/
/** /**
* @ingroup los_perf * @ingroup los_perf
* Define the type of the perf sample data buffer water mark hook function. * Define the type of the perf sample data buffer water mark hook function.
@ -187,13 +182,7 @@ enum PerfEventType {
PERF_EVENT_TYPE_MAX PERF_EVENT_TYPE_MAX
}; };
/*枚举类型 PerfEventType 包含了四个枚举常量：
PERF_EVENT_TYPE_HW：表示硬件事件类型，用于表示板载通用硬件事件。
PERF_EVENT_TYPE_TIMED：表示定时事件类型，用于表示高精度定时器定时事件。
PERF_EVENT_TYPE_SW：表示软件事件类型，用于表示软件跟踪事件。
PERF_EVENT_TYPE_RAW：表示原始事件类型，用于表示特殊板载硬件事件，在对应的架构头文件中有关于枚举 PmuEventType 的定义。
通过使用这个枚举类型，可以方便地表示和区分不同类型的性能事件，便于在代码中进行处理和管理。*/
/** /**
* @ingroup los_perf * @ingroup los_perf
* Common hardware pmu events * Common hardware pmu events
@ -210,17 +199,7 @@ enum PmuHwId {
PERF_COUNT_HW_MAX, PERF_COUNT_HW_MAX,
}; };
/*枚举类型 PmuHwId 包含了多个枚举常量，每个常量代表一个具体的硬件事件：
PERF_COUNT_HW_CPU_CYCLES：表示 CPU 循环周期事件。
PERF_COUNT_HW_INSTRUCTIONS：表示指令执行事件。
PERF_COUNT_HW_DCACHE_REFERENCES：表示数据缓存访问事件。
PERF_COUNT_HW_DCACHE_MISSES：表示数据缓存缺失事件。
PERF_COUNT_HW_ICACHE_REFERENCES：表示指令缓存访问事件。
PERF_COUNT_HW_ICACHE_MISSES：表示指令缓存缺失事件。
PERF_COUNT_HW_BRANCH_INSTRUCTIONS：表示分支指令事件。
PERF_COUNT_HW_BRANCH_MISSES：表示分支缺失事件。
通过使用这个枚举类型的常量，可以指定要监控的硬件事件，方便地在代码中进行配置和统计。*/
/** /**
* @ingroup los_perf * @ingroup los_perf
* Common hrtimer timed events * Common hrtimer timed events
@ -241,13 +220,7 @@ enum PmuSwId {
PERF_COUNT_SW_MAX, PERF_COUNT_SW_MAX,
}; };
/*枚举类型 PmuSwId 包含了多个枚举常量，每个常量代表一个具体的软件事件：
PERF_COUNT_SW_TASK_SWITCH：表示任务切换事件。
PERF_COUNT_SW_IRQ_RESPONSE：表示中断响应事件。
PERF_COUNT_SW_MEM_ALLOC：表示内存分配事件。
PERF_COUNT_SW_MUX_PEND：表示互斥锁挂起事件。
通过使用这个枚举类型的常量，可以指定要监控的软件事件，方便地在代码中进行配置和统计。*/
/** /**
* @ingroup los_perf * @ingroup los_perf
* perf sample data types * perf sample data types
@ -262,16 +235,7 @@ enum PerfSampleType {
PERF_RECORD_IP = 1U << 5, /**< record instruction pointer */ PERF_RECORD_IP = 1U << 5, /**< record instruction pointer */
PERF_RECORD_CALLCHAIN = 1U << 6, /**< record backtrace */ PERF_RECORD_CALLCHAIN = 1U << 6, /**< record backtrace */
}; };
/*枚举类型 PerfSampleType 包含了多个枚举常量，每个常量代表一个具体的采样数据类型：
PERF_RECORD_CPU：记录当前 CPU 的 ID。
PERF_RECORD_TID：记录当前任务的 ID。
PERF_RECORD_TYPE：记录事件类型。
PERF_RECORD_PERIOD：记录事件周期。
PERF_RECORD_TIMESTAMP：记录时间戳。
PERF_RECORD_IP：记录指令指针。
PERF_RECORD_CALLCHAIN：记录回溯信息。
通过使用这个枚举类型的常量，可以方便地表示和区分不同类型的性能采样数据，便于在代码中进行处理和管理。*/
/** /**
* @ingroup los_perf * @ingroup los_perf
* perf configuration sub event information * perf configuration sub event information
@ -289,12 +253,7 @@ typedef struct {
BOOL predivided; /**< whether to prescaler (once every 64 counts), BOOL predivided; /**< whether to prescaler (once every 64 counts),
which only take effect on cpu cycle hardware event */ which only take effect on cpu cycle hardware event */
} PerfEventConfig; } PerfEventConfig;
/*type：表示性能事件类型，是一个 UINT32 类型的值，对应于 PerfEventType 枚举。
events：一个数组，用于存储具体的事件信息。每个元素都包含两个成员变量：
eventId：表示特定事件的标识符，是一个 UINT32 类型的值。
period：表示事件的周期，即每隔多少次事件发生时记录一次样本，是一个 UINT32 类型的值。
eventsNr：表示总共的性能事件数量，是一个 UINT32 类型的值。
predivided：表示是否进行预分频（每64个计数器进行一次），仅对CPU循环硬件事件有效。它是一个 BOOL 类型的值，用于表示是否进行预分频操作。*/
/** /**
* @ingroup los_perf * @ingroup los_perf
* perf configuration main information * perf configuration main information
@ -320,17 +279,7 @@ extern VOID OsPerfHook(UINT32 event);
#else #else
#define LOS_PERF(EVENT) #define LOS_PERF(EVENT)
#endif #endif
/*PerfConfigAttr 结构体包含以下成员变量：
eventsCfg：表示性能事件的配置信息，是一个 PerfEventConfig 结构体类型的值。
taskIds：表示任务 ID 的过滤列表，是一个 UINT32 类型的数组，最多可以存储 PERF_MAX_FILTER_TSKS 个任务 ID。
taskIdsNr：表示任务 ID 的数量，是一个 UINT32 类型的值。
sampleType：表示需要采样的数据类型，是一个 UINT32 类型的值，对应于 PerfSampleType 枚举。
needSample：表示是否需要采样数据，是一个 BOOL 类型的值。
taskFilterEnable：表示是否启用任务过滤器，是一个 BOOL 类型的值。
OsPerfHook 函数用于处理性能事件的回调函数，接收一个 UINT32 类型的参数 event，表示触发的性能事件类型。
LOS_PERF 宏定义用于触发性能事件，如果操作系统配置了 LOSCFG_KERNEL_PERF 和 LOSCFG_PERF_SW_PMU 宏，则会调用 OsPerfHook 函数，否则该宏为空操作。*/
/** /**
* @ingroup los_perf * @ingroup los_perf
* @brief Init perf. * @brief Init perf.

57
src/kernel/include/los_printf.h
Unescape View File

@ -46,14 +46,7 @@ extern "C" {
#ifdef LOSCFG_SHELL_LK #ifdef LOSCFG_SHELL_LK
extern void LOS_LkPrint(int level, const char *func, int line, const char *fmt, ...); extern void LOS_LkPrint(int level, const char *func, int line, const char *fmt, ...);
#endif #endif
/*LOS_LkPrint 函数接受以下参数：
level：表示打印消息的级别，是一个整数。
func：表示打印消息的函数名，是一个指向字符常量的指针。
line：表示打印消息所在的行号，是一个整数。
fmt：表示打印消息的格式字符串，是一个指向字符常量的指针。
...：表示可变参数列表，用于根据格式字符串打印相应的消息内容。
该函数用于在操作系统中打印消息，可以根据不同的级别和格式打印出不同的信息，用于调试或记录运行时的相关信息。函数的实现可能在其他地方定义。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* log print level definition, LOS_EMG_LEVEL is set to 0, it means the log is emergency. * log print level definition, LOS_EMG_LEVEL is set to 0, it means the log is emergency.
@ -104,14 +97,7 @@ fmt
#endif #endif
typedef VOID (*pf_OUTPUT)(const CHAR *fmt, ...); typedef VOID (*pf_OUTPUT)(const CHAR *fmt, ...);
/*这段代码定义了一个名为 PRINT_LEVEL 的宏以及一个名为 pf_OUTPUT 的函数指针类型。
PRINT_LEVEL 宏根据条件判断是否定义为 LOS_DEBUG_LEVEL 或者 LOS_ERR_LEVEL。
如果宏 LOSCFG_SHELL_LK 被定义，则 PRINT_LEVEL 被定义为 LOS_DEBUG_LEVEL。
否则， PRINT_LEVEL 被定义为 LOS_ERR_LEVEL。
pf_OUTPUT 是一个函数指针类型，指向一个返回值为 VOID 的函数，
该函数接受一个格式化字符串参数 fmt 和可变参数列表 ...。该函数指针类型可以用于声明指向相应函数的指针变量，使得函数的调用可以通过该指针进行。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* @brief Format and print data. * @brief Format and print data.
@ -167,15 +153,7 @@ extern void dprintf(const char *fmt, ...);
#endif #endif
#endif #endif
#endif #endif
/*当宏 PRINT_DEBUG 未被定义时，通过条件编译判断 PRINT_LEVEL 是否小于 LOS_DEBUG_LEVEL。如果是，则将 PRINT_DEBUG 宏定义为空操作；否则，进入下一层条件编译。
当宏 LOSCFG_SHELL_LK 被定义时，PRINT_DEBUG 宏被定义为调用 LOS_LkPrint 函数，
输出 [DEBUG] 级别的日志信息，其中第一个参数为日志级别 LOS_DEBUG_LEVEL，
第二个参数为当前函数名 __FUNCTION__，第三个参数为当前行号 __LINE__，
第四个参数为格式化字符串 fmt，后面的可变参数列表 ...
用于补充格式化字符串中占位符的值。
否则，PRINT_DEBUG 宏被定义为输出 [DEBUG] 级别的日志信息到控制台。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* @brief Format and print information log. * @brief Format and print information log.
@ -209,15 +187,7 @@ extern void dprintf(const char *fmt, ...);
#endif #endif
#endif #endif
#endif #endif
/*当宏 PRINT_INFO 未被定义时，通过条件编译判断 PRINT_LEVEL 是否小于 LOS_INFO_LEVEL。
如果是，则将 PRINT_INFO 宏定义为空操作；否则，进入下一层条件编译。
当宏 LOSCFG_SHELL_LK 被定义时，PRINT_INFO 宏被定义为调用 LOS_LkPrint 函数，
输出 [INFO] 级别的日志信息，其中第一个参数为日志级别 LOS_INFO_LEVEL，
第二个参数为当前函数名 __FUNCTION__，第三个参数为当前行号 __LINE__，
第四个参数为格式化字符串 fmt，后面的可变参数列表 ... 用于补充格式化字符串中占位符的值。
否则，PRINT_INFO 宏被定义为输出 [INFO] 级别的日志信息到控制台。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* @brief Format and print warning log. * @brief Format and print warning log.
@ -251,14 +221,7 @@ extern void dprintf(const char *fmt, ...);
#endif #endif
#endif #endif
#endif #endif
/*当宏 PRINT_WARN 未被定义时，通过条件编译判断 PRINT_LEVEL 是否小于 LOS_WARN_LEVEL。如果是，则将 PRINT_WARN 宏定义为空操作；否则，进入下一层条件编译。
当宏 LOSCFG_SHELL_LK 被定义时，PRINT_WARN 宏被定义为调用 LOS_LkPrint 函数，
输出 [WARN] 级别的日志信息，其中第一个参数为日志级别 LOS_WARN_LEVEL，
第二个参数为当前函数名 __FUNCTION__，第三个参数为当前行号 __LINE__，
第四个参数为格式化字符串 fmt，后面的可变参数列表 ... 用于补充格式化字符串中占位符的值。
否则，PRINT_WARN 宏被定义为输出 [WARN] 级别的日志信息到控制台。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* @brief Format and print error log. * @brief Format and print error log.
@ -292,14 +255,7 @@ extern void dprintf(const char *fmt, ...);
#endif #endif
#endif #endif
#endif #endif
/*当宏 PRINT_ERR 未被定义时，通过条件编译判断 PRINT_LEVEL 是否小于 LOS_ERR_LEVEL。如果是，则将 PRINT_ERR 宏定义为空操作；否则，进入下一层条件编译。
当宏 LOSCFG_SHELL_LK 被定义时，PRINT_ERR 宏被定义为调用 LOS_LkPrint 函数，
输出 [ERR] 级别的日志信息，其中第一个参数为日志级别 LOS_ERR_LEVEL
，第二个参数为当前函数名 __FUNCTION__，第三个参数为当前行号 __LINE__，
第四个参数为格式化字符串 fmt，后面的可变参数列表 ... 用于补充格式化字符串中占位符的值。
否则，PRINT_ERR 宏被定义为输出 [ERR] 级别的日志信息到控制台。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* @brief Format and print common log. * @brief Format and print common log.
@ -331,16 +287,7 @@ extern void dprintf(const char *fmt, ...);
#endif #endif
#endif #endif
#endif #endif
/*这段代码定义了一个名为 PRINTK 的宏。
当宏 PRINTK 未被定义时，通过条件编译判断 PRINT_LEVEL 是否小于 LOS_COMMOM_LEVEL。如果是，则将 PRINTK 宏定义为空操作；否则，进入下一层条件编译。
当宏 LOSCFG_SHELL_LK 被定义时，PRINTK 宏被定义为调用 LOS_LkPrint 函数，
输出 [COMM] 级别的日志信息，其中第一个参数为日志级别 LOS_COMMOM_LEVEL，
第二个参数为当前函数名 __FUNCTION__，第三个参数为当前行号 __LINE__，
第四个参数为格式化字符串 fmt，后面的可变参数列表 ... 用于补充格式化字符串中占位符的值。
否则，PRINTK 宏被定义为输出格式化字符串到控制台。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* @brief Format and print emergency log. * @brief Format and print emergency log.
@ -370,11 +317,7 @@ extern void dprintf(const char *fmt, ...);
} while (0) } while (0)
#endif #endif
#endif #endif
/*这段代码定义了一个名为 PRINT_EMG 的宏。
当宏 PRINT_EMG 未被定义时，通过条件编译判断 PRINT_LEVEL 是否小于 LOS_EMG_LEVEL。如果是，则将 PRINT_EMG 宏定义为空操作；否则，进入下一层条件编译。
在 PRINT_LEVEL 大于等于 LOS_EMG_LEVEL 时，PRINT_EMG 宏被定义为输出 [EMG] 级别的日志信息到控制台。*/
/** /**
* @ingroup los_printf * @ingroup los_printf
* @brief Format and print log. * @brief Format and print log.

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

@ -55,9 +55,7 @@ extern "C" {
* @deprecated This error code is obsolete since LiteOS 5.0.0. * @deprecated This error code is obsolete since LiteOS 5.0.0.
*/ */
#define LOS_ERRNO_QUEUE_MAXNUM_ZERO LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x00) #define LOS_ERRNO_QUEUE_MAXNUM_ZERO LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x00)
/*宏的定义使用了 LOS_ERRNO_OS_ERROR 宏，并指定了参数 LOS_MOD_QUE 和 0x00。根据上下文推测，LOS_MOD_QUE 可能是表示与队列相关的模块。
该宏的作用是生成一个错误码，用于表示队列的最大数量为零的错误情况。具体的错误码值可能在其他地方定义。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* Queue error code: The queue block memory fails to be initialized. * Queue error code: The queue block memory fails to be initialized.
@ -68,11 +66,7 @@ extern "C" {
* number of queue resources. * number of queue resources.
*/ */
#define LOS_ERRNO_QUEUE_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x01) #define LOS_ERRNO_QUEUE_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x01)
/*这段代码定义了一个名为 LOS_ERRNO_QUEUE_NO_MEMORY 的宏，用于表示队列分配内存失败时的错误码。
宏的定义使用了 LOS_ERRNO_OS_ERROR 宏，并指定了参数 LOS_MOD_QUE 和 0x01。根据上下文推测，LOS_MOD_QUE 可能是表示与队列相关的模块。
该宏的作用是生成一个错误码，用于表示队列分配内存失败的错误情况。具体的错误码值可能在其他地方定义。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* Queue error code: The memory for queue creation fails to be requested. * Queue error code: The memory for queue creation fails to be requested.
@ -83,11 +77,7 @@ extern "C" {
* the number of nodes in the queue to be created. * the number of nodes in the queue to be created.
*/ */
#define LOS_ERRNO_QUEUE_CREATE_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x02) #define LOS_ERRNO_QUEUE_CREATE_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x02)
/*这段代码定义了一个名为 LOS_ERRNO_QUEUE_CREATE_NO_MEMORY 的宏，用于表示创建队列时内存分配失败的错误码。
该宏使用了 LOS_ERRNO_OS_ERROR 宏，并指定了参数 LOS_MOD_QUE 和 0x02。根据上下文推测，LOS_MOD_QUE 可能是表示与队列相关的模块。
因此，该宏的作用是生成一个错误码，用于表示创建队列时内存分配失败的错误情况。具体的错误码值可能在其他地方定义。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* Queue error code: The size of the biggest message in the created queue is too big. * Queue error code: The size of the biggest message in the created queue is too big.
@ -97,9 +87,6 @@ extern "C" {
* Solution: Change the size of the biggest message in the created queue. * Solution: Change the size of the biggest message in the created queue.
*/ */
#define LOS_ERRNO_QUEUE_SIZE_TOO_BIG LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x03) #define LOS_ERRNO_QUEUE_SIZE_TOO_BIG LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x03)
/*宏的定义使用了 LOS_ERRNO_OS_ERROR 宏，并指定了参数 LOS_MOD_QUE 和 0x00。根据上下文推测，LOS_MOD_QUE 可能是表示与队列相关的模块。
该宏的作用是生成一个错误码，用于表示队列的最大数量为零的错误情况。具体的错误码值可能在其他地方定义。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
@ -110,11 +97,6 @@ extern "C" {
* Solution: Increase the configured number of resources for queues. * Solution: Increase the configured number of resources for queues.
*/ */
#define LOS_ERRNO_QUEUE_CB_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x04) #define LOS_ERRNO_QUEUE_CB_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_QUE, 0x04)
/*这段代码定义了一个名为 LOS_ERRNO_QUEUE_NO_MEMORY 的宏，用于表示队列分配内存失败时的错误码。
宏的定义使用了 LOS_ERRNO_OS_ERROR 宏，并指定了参数 LOS_MOD_QUE 和 0x01。根据上下文推测，LOS_MOD_QUE 可能是表示与队列相关的模块。
该宏的作用是生成一个错误码，用于表示队列分配内存失败的错误情况。具体的错误码值可能在其他地方定义。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
@ -374,21 +356,6 @@ typedef struct tagQueueInfo {
} QUEUE_INFO_S; } QUEUE_INFO_S;
#ifdef LOSCFG_QUEUE_STATIC_ALLOCATION #ifdef LOSCFG_QUEUE_STATIC_ALLOCATION
/*这段代码定义了一个结构体 QUEUE_INFO_S，用于描述队列（Queue）的信息。
成员变量解释如下：
uwQueueID：队列 ID。
usQueueLen：队列长度，即队列中节点的数量。
usQueueSize：队列中每个节点的大小。
usQueueHead：队列头节点的位置，是一个数组下标。
usQueueTail：队列尾节点的位置，是一个数组下标。
usWritableCnt：可写入的资源数。
usReadableCnt：可读取的资源数。
uwWaitReadTask：等待读取消息的任务。是一个 64 位的无符号整数，每个二进制位表示一个任务 ID。因此，可以表示 64 个任务，最大任务 ID 是 63。
uwWaitWriteTask：等待写入消息的任务。同 uwWaitReadTask。
uwWaitMemTask：等待内存的任务。同 uwWaitReadTask。
如果宏 LOSCFG_QUEUE_STATIC_ALLOCATION 被定义，则这个结构体用于动态分配内存时不起作用。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Create a message queue. * @brief Create a message queue.
@ -430,16 +397,7 @@ extern UINT32 LOS_QueueCreateStatic(const CHAR *queueName,
VOID *queueMem, VOID *queueMem,
UINT16 memSize); UINT16 memSize);
#endif #endif
/*该函数用于静态创建一个队列（Queue），具体参数如下：
queueName：队列的名称，类型为 const CHAR*。
len：队列的长度，即队列中节点的数量，类型为 UINT16。
queueId：指向一个 UINT32 类型的指针，用于存储创建得到的队列 ID。
flags：队列的标志，类型为 UINT32。
maxMsgSize：队列中每个节点的最大消息大小，类型为 UINT16。
queueMem：指向预分配的队列内存的指针，类型为 VOID*。
memSize：预分配的队列内存的大小，类型为 UINT16。
该函数的作用是在预分配的静态内存空间上创建一个队列，并返回队列的 ID*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Create a message queue. * @brief Create a message queue.
@ -473,14 +431,7 @@ extern UINT32 LOS_QueueCreate(const CHAR *queueName,
UINT32 *queueId, UINT32 *queueId,
UINT32 flags, UINT32 flags,
UINT16 maxMsgSize); UINT16 maxMsgSize);
/*该函数用于动态创建一个队列（Queue），具体参数如下：
queueName：队列的名称，类型为 const CHAR*。
len：队列的长度，即队列中节点的数量，类型为 UINT16。
queueId：指向一个 UINT32 类型的指针，用于存储创建得到的队列 ID。
flags：队列的标志，类型为 UINT32。
maxMsgSize：队列中每个节点的最大消息大小，类型为 UINT16。
该函数的作用是在运行时动态分配内存空间来创建一个队列，并返回队列的 ID。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Read a queue. * @brief Read a queue.
@ -530,7 +481,7 @@ extern UINT32 LOS_QueueReadCopy(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 *bufferSize, UINT32 *bufferSize,
UINT32 timeout); UINT32 timeout);
/*该函数的作用是从队列中读取数据，并将数据复制到指定的缓冲区中。如果队列中没有数据可读，则根据超时时间等待数据可读，如果在超时时间内仍然没有数据可读，则返回错误码。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Write data into a queue. * @brief Write data into a queue.
@ -578,13 +529,7 @@ extern UINT32 LOS_QueueWriteCopy(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 bufferSize, UINT32 bufferSize,
UINT32 timeout); UINT32 timeout);
/*该函数用于向指定的队列中写入数据，具体参数如下：
queueId：要写入数据的队列 ID，类型为 UINT32。
bufferAddr：指向待写入数据的缓冲区地址，类型为 VOID*。
bufferSize：待写入数据的大小，类型为 UINT32。
timeout：写入数据的超时时间，单位为 Tick。如果设置为 0，则表示不等待，立即返回。如果设置为 LOS_WAIT_FOREVER，则表示一直等待，直到有空间可写入为止，类型为 UINT32。
该函数的作用是向队列中写入数据，如果队列已满，则根据超时时间等待空间可写入，如果在超时时间内仍然没有空间可写入，则返回错误码。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Read a queue. * @brief Read a queue.
@ -636,13 +581,7 @@ extern UINT32 LOS_QueueRead(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 bufferSize, UINT32 bufferSize,
UINT32 timeout); UINT32 timeout);
/*该函数用于从指定的队列中读取数据，具体参数如下：
queueId：要读取数据的队列 ID，类型为 UINT32。
bufferAddr：指向存储读取数据的缓冲区地址，类型为 VOID*。
bufferSize：指定缓冲区的大小，即期望读取的数据大小，类型为 UINT32。
timeout：读取数据的超时时间，单位为 Tick。如果设置为 0，则表示不等待，立即返回。如果设置为 LOS_WAIT_FOREVER，则表示一直等待，直到有数据可读为止，类型为 UINT32。
该函数的作用是从队列中读取数据并存储到指定的缓冲区中。如果队列中没有足够的数据可读，则根据超时时间等待数据可读，如果在超时时间内仍然没有足够的数据可读，则返回错误码。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Write data into a queue. * @brief Write data into a queue.
@ -691,13 +630,7 @@ extern UINT32 LOS_QueueWrite(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 bufferSize, UINT32 bufferSize,
UINT32 timeout); UINT32 timeout);
/*该函数用于向指定的队列中写入数据，具体参数如下：
queueId：要写入数据的队列 ID，类型为 UINT32。
bufferAddr：指向待写入数据的缓冲区地址，类型为 VOID*。
bufferSize：待写入数据的大小，类型为 UINT32。
timeout：写入数据的超时时间，单位为 Tick。如果设置为 0，则表示不等待，立即返回。如果设置为 LOS_WAIT_FOREVER，则表示一直等待，直到有空间可写入为止，类型为 UINT32。
该函数的作用是向队列中写入数据，如果队列已满，则根据超时时间等待空间可写入，如果在超时时间内仍然没有空间可写入，则返回错误码。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Write data into a queue header. * @brief Write data into a queue header.
@ -746,13 +679,7 @@ extern UINT32 LOS_QueueWriteHead(UINT32 queueId,
VOID *bufferAddr, VOID *bufferAddr,
UINT32 bufferSize, UINT32 bufferSize,
UINT32 timeout); UINT32 timeout);
/*该函数用于向指定队列的队首写入数据，具体参数如下：
queueId：要写入数据的队列 ID，类型为 UINT32。
bufferAddr：指向待写入数据的缓冲区地址，类型为 VOID*。
bufferSize：待写入数据的大小，类型为 UINT32。
timeout：写入数据的超时时间，单位为 Tick。如果设置为 0，则表示不等待，立即返回。如果设置为 LOS_WAIT_FOREVER，则表示一直等待，直到有空间可写入为止，类型为 UINT32。
该函数的作用是向队列的队首写入数据，如果队列已满，则根据超时时间等待空间可写入，如果在超时时间内仍然没有空间可写入，则返回错误码。写入数据到队首可能会导致队列中原本的数据被挤出。*/
/** /**
* @ingroup los_queue * @ingroup los_queue
* @brief Write data into a queue header. * @brief Write data into a queue header.

25
src/kernel/include/los_ringbuf.h
Unescape View File

@ -51,14 +51,7 @@ typedef enum {
RBUF_UNINIT, /**< Ringbuf is not inited. */ RBUF_UNINIT, /**< Ringbuf is not inited. */
RBUF_INITED /**< Ringbuf is inited. */ RBUF_INITED /**< Ringbuf is inited. */
} RingbufStatus; } RingbufStatus;
/*这段代码定义了一个名为 RingbufStatus 的枚举类型，表示环形缓冲区的状态。
该枚举类型包含两个枚举值：
RBUF_UNINIT：表示环形缓冲区尚未初始化。
RBUF_INITED：表示环形缓冲区已经初始化。
通过使用这个枚举类型，可以方便地标识和判断环形缓冲区的状态。
在使用环形缓冲区时，可以根据不同的状态进行相应的操作或处理。*/
/** /**
* @ingroup los_ringbuf * @ingroup los_ringbuf
* Ringbuf information structure. * Ringbuf information structure.
@ -73,18 +66,7 @@ typedef struct {
RingbufStatus status; /**< Ringbuf status */ RingbufStatus status; /**< Ringbuf status */
CHAR *fifo; /**< Buf to store data */ CHAR *fifo; /**< Buf to store data */
} Ringbuf; } Ringbuf;
/*这段代码定义了一个名为 Ringbuf 的结构体，用于表示环形缓冲区的属性和状态。
该结构体包含以下成员：
startIdx：环形缓冲区的读取索引。
endIdx：环形缓冲区的写入索引。
size：环形缓冲区的总大小。
remain：环形缓冲区的剩余可用空间大小。
lock：用于读取和写入操作的自旋锁。
status：环形缓冲区的状态，类型为 RingbufStatus 枚举类型。
fifo：用于存储数据的缓冲区。
通过这个结构体，可以方便地管理环形缓冲区的属性和状态，并进行相应的数据读写操作。*/
/** /**
* @ingroup los_ringbuf * @ingroup los_ringbuf
* @brief Init a ringbuf. * @brief Init a ringbuf.
@ -107,8 +89,7 @@ fifo
* @since Huawei LiteOS V200R005C00 * @since Huawei LiteOS V200R005C00
*/ */
extern UINT32 LOS_RingbufInit(Ringbuf *ringbuf, CHAR *fifo, UINT32 size); extern UINT32 LOS_RingbufInit(Ringbuf *ringbuf, CHAR *fifo, UINT32 size);
/*该函数的作用是根据给定的参数初始化环形缓冲区对象，并分配必要的资源。通过调用这个函数，可以将一个已经定义的 Ringbuf
结构体对象与指定的缓冲区关联起来，并设置初始状态和属性。*/
/** /**
* @ingroup los_ringbuf * @ingroup los_ringbuf
* @brief Reset a ringbuf. * @brief Reset a ringbuf.
@ -150,9 +131,7 @@ extern VOID LOS_RingbufReset(Ringbuf *ringbuf);
* @since Huawei LiteOS V200R005C00 * @since Huawei LiteOS V200R005C00
*/ */
extern UINT32 LOS_RingbufWrite(Ringbuf *ringbuf, const CHAR *buf, UINT32 size); extern UINT32 LOS_RingbufWrite(Ringbuf *ringbuf, const CHAR *buf, UINT32 size);
/*该函数的作用是将指定大小的数据从源缓冲区写入到目标环形缓冲区中。写入操作会更新环形缓冲区的写入索引，并根据需要循环覆盖已有数据。如果环形缓冲区的空间不足以容纳全部数据，只会写入部分数据。
通过调用这个函数，可以方便地将数据写入到环形缓冲区中，并实现数据的循环存储和覆盖。*/
/** /**
* @ingroup los_ringbuf * @ingroup los_ringbuf
* @brief Read data from ringbuf. * @brief Read data from ringbuf.
@ -174,9 +153,7 @@ extern UINT32 LOS_RingbufWrite(Ringbuf *ringbuf, const CHAR *buf, UINT32 size);
* @since Huawei LiteOS V200R005C00 * @since Huawei LiteOS V200R005C00
*/ */
extern UINT32 LOS_RingbufRead(Ringbuf *ringbuf, CHAR *buf, UINT32 size); extern UINT32 LOS_RingbufRead(Ringbuf *ringbuf, CHAR *buf, UINT32 size);
/*该函数的作用是从指定大小的数据中读取数据，并将其存储到目标缓冲区。读取操作会更新环形缓冲区的读取索引，并根据需要循环读取已有数据。如果环形缓冲区中的数据不足以满足全部读取请求，只会读取部分数据。
通过调用这个函数，可以方便地从环形缓冲区中读取数据，并实现数据的循环读取和覆盖。*/
/** /**
* @ingroup los_ringbuf * @ingroup los_ringbuf
* @brief Get a ringbuf's used size. * @brief Get a ringbuf's used size.

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 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*该函数定义提供了运行停止功能所需的接口和参数类型，为嵌入式系统中的运行停止操作提供了基本的支持
/** /**
* @defgroup los_runstop Wakeup * @defgroup los_runstop Wakeup
* @ingroup kernel * @ingroup kernel
*/ */
#ifndef _LOS_RUNSTOP_H 组的定义：该组包含了一些与运行停止有关的函数和宏定义。 #ifndef _LOS_RUNSTOP_H
#define _LOS_RUNSTOP_H #define _LOS_RUNSTOP_H
#include "los_typedef.h"包含了 LOS Kernel 所需的基本类型定义。 #include "los_typedef.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
@ -43,7 +43,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/** /**
* @ingroup los_runstop ##该回调函数类型定义用于在唤醒阶段调用。它允许用户定义一个函数，当系统从休眠状态唤醒时，该函数将被调用 * @ingroup los_runstop
* @brief Define the type of a runstop callback function. * @brief Define the type of a runstop callback function.
* *
* @par Description: * @par Description:
@ -63,7 +63,7 @@ extern "C" {
* @see None. * @see None.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
typedef VOID (*RUNSTOP_CALLBACK_FUNC)(VOID);/*函数指针类型RUNSTOP_CALLBACK_FUNC，用于定义运行停止时的回调函数，没有参数和返回值 typedef VOID (*RUNSTOP_CALLBACK_FUNC)(VOID);
/** /**
* @ingroup los_runstop * @ingroup los_runstop
@ -88,10 +88,7 @@ typedef VOID (*RUNSTOP_CALLBACK_FUNC)(VOID);/*函数指针类型RUNSTOP_CALLBACK
* @see None. * @see None.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
typedef INT32 (*FLASH_READ_FUNC)(VOID *memAddr, size_t start, size_t size);/*定义了一个名为FLASH_READ_FUNC的函数指针类型，用于定义一个从Flash中读取数据的函数 typedef INT32 (*FLASH_READ_FUNC)(VOID *memAddr, size_t start, size_t size);
memAddr：用于存储从Flash中读取数据的内存起始地址
start：从Flash中读取数据的起始地址
size：从Flash中读取的数据大小。
/** /**
* @ingroup los_runstop * @ingroup los_runstop
@ -116,10 +113,7 @@ size：从Flash中读取的数据大小。
* @see None. * @see None.
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
typedef INT32 (*FLASH_WRITE_FUNC)(VOID *memAddr, size_t start, size_t size);/*定义一个用于写入flash数据的函数类 typedef INT32 (*FLASH_WRITE_FUNC)(VOID *memAddr, size_t start, size_t size);
memAddr：要从中读取数据并写入到某个flash的内存起始地址。
start：要写入数据的某个flash的起始地址。
size：要写入到某个flash的数据的大小
/** /**
* @ingroup los_runstop * @ingroup los_runstop
@ -128,17 +122,20 @@ size：要写入到某个flash的数据的大小
* Information of specified parameters passed in during runstop. * Information of specified parameters passed in during runstop.
*/ */
typedef struct tagRunstopParam { typedef struct tagRunstopParam {
RUNSTOP_CALLBACK_FUNC pfIdleWakeupCallback; /*< 空闲任务中的唤醒回调函数 */ RUNSTOP_CALLBACK_FUNC pfIdleWakeupCallback; /* < Wake up callback function, called in idle task */
RUNSTOP_CALLBACK_FUNC pfWakeupCallback; /*< 唤醒回调函数 */ RUNSTOP_CALLBACK_FUNC pfWakeupCallback; /* < Wake up callback function */
RUNSTOP_CALLBACK_FUNC pfImageDoneCallback; /*< 内存存储完成后的回调函数 */ RUNSTOP_CALLBACK_FUNC pfImageDoneCallback; /* < Image done callback function, called just after memory is stored */
FLASH_READ_FUNC pfFlashReadFunc; /*< 从某个闪存中读取数据的抽象函数 */ FLASH_READ_FUNC pfFlashReadFunc; /* < An abstract function for reading data from a certain flash */
FLASH_WRITE_FUNC pfFlashWriteFunc; /*< 向某个闪存中写入数据的抽象函数 */ FLASH_WRITE_FUNC pfFlashWriteFunc; /* < An abstract function for writing data to a certain flash */
size_t uwFlashReadAlignSize; /*< 从某个闪存中读取数据时的块对齐大小 */ size_t uwFlashReadAlignSize; /* < Block align size when reading data from a certain flash */
size_t uwFlashEraseAlignSize; /*< 擦除某个闪存中数据时的块对齐大小 */ size_t uwFlashEraseAlignSize; /* < Block align size when erasing data in a certain flash */
size_t uwFlashWriteAlignSize; /*< 向某个闪存中写入数据时的块对齐大小 */ size_t uwFlashWriteAlignSize; /* < Block align size when writing data to a certain flash */
UINTPTR uwWowFlashAddr; /* < 存储内存的闪存起始地址，地址应与闪存写入对齐长度对齐 */ UINTPTR uwWowFlashAddr; /* < The flash starting address to which the memory is to be
UINTPTR uwImageFlashAddr; /* < 整个应用程序镜像烧录到的闪存起始地址 */ stored, the address should be flash write-alignment length
} RUNSTOP_PARAM_S;/*是用于传递和配置运行停止功能所需的参数信息 aligned */
UINTPTR uwImageFlashAddr; /* < The flash starting address where the whole application image
is burned */
} RUNSTOP_PARAM_S;
/** /**
* @ingroup los_runstop * @ingroup los_runstop
@ -162,8 +159,8 @@ typedef struct tagRunstopParam {
* @see * @see
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern VOID LOS_MakeImage(const RUNSTOP_PARAM_S *runstopParam);/*定义了一个名为LOS_MakeImage的函数，用于将内存映像存储到flash中。 extern VOID LOS_MakeImage(const RUNSTOP_PARAM_S *runstopParam);
函数接受一个名为runstopParam的参数，该参数包含了一些关键信息，用于runstop使用，包括要存储内存映像的flash起始地址等。
#ifdef __cplusplus #ifdef __cplusplus
#if __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 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这段代码实现了对信号量操作的基本功能，包括创建、删除、请求和释放信号量，并对可能出现的错误情况进行了定义和说明。*/
/** /**
* @defgroup los_sem Semaphore * @defgroup los_sem Semaphore
* @ingroup kernel * @ingroup kernel
@ -49,17 +49,17 @@ extern "C" {
* @ingroup los_sem * @ingroup los_sem
* Max count of counting semaphores * Max count of counting semaphores
*/ */
#define LOS_SEM_COUNT_MAX 0xFFFE/*计数信号量的最大值*/ #define LOS_SEM_COUNT_MAX 0xFFFE
/** /**
* @ingroup los_sem 该宏定义属于信号量模块。 * @ingroup los_sem
* Semaphore error code: The memory is insufficient. 内存不足 * 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)/*定义一个信号量（Semaphore）的错误码，表示内存不足 #define LOS_ERRNO_SEM_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x00)
/** /**
* @ingroup los_sem * @ingroup los_sem
@ -72,15 +72,14 @@ extern "C" {
#define LOS_ERRNO_SEM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x01) #define LOS_ERRNO_SEM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x01)
/** /**
* @ingroup los_sem 该宏定义属于信号量模块。 * @ingroup los_sem
* Semaphore error code: Null pointer. 该错误码的含义为参数无效。 * 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 * @ingroup los_sem
@ -88,9 +87,9 @@ extern "C" {
* *
* Value: 0x02000703. * 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 * @ingroup los_sem
@ -98,9 +97,9 @@ extern "C" {
* *
* Value: 0x02000704. * 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 * @ingroup los_sem
@ -108,9 +107,9 @@ extern "C" {
* *
* Value: 0x02000705. * Value: 0x02000705.
* *
* Solution: Do not call the API during an interrupt.解决该错误的方法a:不要在中断期间调用该API * Solution: Do not call the API during an interrupt.
*/ */
#define LOS_ERRNO_SEM_PEND_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x05)/*定义了一个信号量模块的错误码，表示在中断期间调用了该API，这是被禁止的*/ #define LOS_ERRNO_SEM_PEND_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x05)
/** /**
* @ingroup los_sem * @ingroup los_sem
@ -118,9 +117,9 @@ extern "C" {
* *
* Value: 0x02000706. * Value: 0x02000706.
* *
* Solution: Do not call LOS_SemPend when task scheduling is locked.解决该错误的方法：在任务调度被锁定时不要调用LOS_SemPend函数 * Solution: Do not call LOS_SemPend when task scheduling is locked.
*/ */
#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 * @ingroup los_sem
@ -128,9 +127,9 @@ extern "C" {
* *
* Value: 0x02000707. * 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 * @ingroup los_sem
@ -138,9 +137,9 @@ extern "C" {
* *
* Value: 0x02000708. * 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 * @ingroup los_sem
@ -149,9 +148,9 @@ extern "C" {
* *
* Value: 0x02000709. * 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 * @ingroup los_sem
@ -160,10 +159,10 @@ extern "C" {
* *
* Value: 0x0200070A. * Value: 0x0200070A.
* *
* Solution: Do not call the API in the system-level callback.解决该错误的方法，即不要在系统级回调中调用该API。 * Solution: Do not call the API in the system-level callback.
* @deprecated This error code is obsolete since LiteOS 5.0.0.该错误码自LiteOS 5.0.0版本起已经过时。 * @deprecated This error code is obsolete since LiteOS 5.0.0.
*/ */
#define LOS_ERRNO_SEM_PEND_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x0A)/*定义了一个信号量模块的错误码，表示在系统级回调中调用了该API，这是被禁止的*/ #define LOS_ERRNO_SEM_PEND_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_SEM, 0x0A)
/** /**
* @ingroup los_sem * @ingroup los_sem
@ -188,8 +187,7 @@ extern "C" {
* @see LOS_SemDelete | LOS_BinarySemCreate * @see LOS_SemDelete | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle);/*这段代码声明了一个函数LOS_SemCreate，用于创建信号量。该函数根据传入的初始可用信号量数量， extern UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle);
创建一个信号量控制结构，并返回该信号量控制结构的ID。函数的返回值包括多种情况，如传入的参数为空指针、传入的初始可用信号量数量超过最大数量、没有可用的信号量控制结构等。*/
/** /**
* @ingroup los_sem * @ingroup los_sem
@ -214,7 +212,7 @@ extern UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle);/*这段代码声
* @see LOS_SemCreate | LOS_SemDelete * @see LOS_SemCreate | LOS_SemDelete
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle);/*声明了一个函数原型 LOS_BinarySemCreate，用于创建一个二进制信号量。*/ extern UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle);
/** /**
* @ingroup los_sem * @ingroup los_sem
@ -237,7 +235,7 @@ extern UINT32 LOS_BinarySemCreate(UINT16 count, UINT32 *semHandle);/*声明了
* @see LOS_SemCreate | LOS_BinarySemCreate * @see LOS_SemCreate | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_SemDelete(UINT32 semHandle);/*这段代码定义了一个函数LOS_SemDelete，用于删除一个信号量的控制结构*/ extern UINT32 LOS_SemDelete(UINT32 semHandle);
/** /**
* @ingroup los_sem * @ingroup los_sem
@ -274,19 +272,7 @@ extern UINT32 LOS_SemDelete(UINT32 semHandle);/*这段代码定义了一个函
* @see LOS_SemPost | LOS_SemCreate | LOS_BinarySemCreate * @see LOS_SemPost | LOS_SemCreate | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00 * @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 * @ingroup los_sem
@ -308,12 +294,7 @@ timeout参数指定等待信号量的超时时间，如果timeout值为0，表
* @see LOS_SemPend | LOS_SemCreate | LOS_BinarySemCreate * @see LOS_SemPend | LOS_SemCreate | LOS_BinarySemCreate
* @since Huawei LiteOS V100R001C00 * @since Huawei LiteOS V100R001C00
*/ */
extern UINT32 LOS_SemPost(UINT32 semHandle);/*这段代码定义了一个函数LOS_SemPost，用于释放一个信号量*/ extern UINT32 LOS_SemPost(UINT32 semHandle);
/*LOS_SemPost用于释放由semHandle指定的信号量控制结构。
若释放前没有先创建指定的信号量，则会返回LOS_ERRNO_SEM_INVALID。
若信号量释放的次数超过允许的最大次数，则会返回LOS_ERRNO_SEM_OVERFLOW。
若成功释放信号量，则会返回LOS_OK。
此函数依赖于LOS_SemPend、LOS_SemCreate和LOS_BinarySemCreate函数。*/
#ifdef __cplusplus #ifdef __cplusplus
#if __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 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*以上代码是关于内存管理中的slab功能的实现。Slab是一种分配固定大小的内存块的机制，用于提高内存分配和释放的效率。以上代码提供了对slab内存分配器的配置和定义*/
/** /**
* @defgroup los_slab Slab * @defgroup los_slab Slab
* @ingroup kernel * @ingroup kernel
@ -46,9 +46,9 @@ extern "C" {
* @ingroup los_slab * @ingroup los_slab
* total size of each slab class. * total size of each slab class.
*/ */
#define SLAB_MEM_ALLOCATOR_SIZE 512U /*宏定义SLAB_MEM_ALLOCATOR_SIZE表示每个slab class（一种内存分配方式）所需要的总大小为512字节*/ #define SLAB_MEM_ALLOCATOR_SIZE 512U
#define SLAB_BASIC_NEED_SIZE 0x1000 /*宏定义SLAB_BASIC_NEED_SIZE表示内存分配时最小需要的空间为0x1000字节（即4KB）。*/ #define SLAB_BASIC_NEED_SIZE 0x1000
/** /**
* @ingroup los_slab * @ingroup los_slab
@ -63,14 +63,7 @@ enum SlabBucketSizeType {
#define SLAB_MEM_BUCKET_SIZE_TYPE SLAB_BUCKET_SIZE_HALF_OF_HEAP #define SLAB_MEM_BUCKET_SIZE_TYPE SLAB_BUCKET_SIZE_HALF_OF_HEAP
#endif #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 * @ingroup los_slab
* @brief configure slab size. * @brief configure slab size.
@ -93,11 +86,8 @@ SLAB_BUCKET_SIZE_TYPE_MAX：表示枚举类型的最大取值。
* </ul> * </ul>
* @since Huawei LiteOS V200R003C00 * @since Huawei LiteOS V200R003C00
*/ */
extern VOID LOS_SlabSizeCfg(UINT32 *cfg, UINT32 cnt);/*段代码是关于操作系统内存管理中的slab功能的配置函数。Slab是一种分配固定大小的内存块的机制， extern VOID LOS_SlabSizeCfg(UINT32 *cfg, UINT32 cnt);
用于提高内存分配和释放的效率*/
/*该函数LOS_SlabSizeCfg用于配置slab的大小。它接受两个参数：
cfg：指向slab大小配置表的指针。这个配置表包含了每个slab类的大小信息。
cnt：slab类的数量，必须与配置表中的项数相匹配*/
#ifdef __cplusplus #ifdef __cplusplus
#if __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 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
/*以上代码实现了自旋锁的基本操作，并根据多处理器系统和非多处理器系统分别进行了处理*/
/** /**
* @defgroup los_spinlock Spinlock * @defgroup los_spinlock Spinlock
* @ingroup kernel * @ingroup kernel
@ -55,19 +55,13 @@ extern "C" {
#define LOCKDEP_CHECK_OUT(lock) OsLockDepCheckOut(lock) #define LOCKDEP_CHECK_OUT(lock) OsLockDepCheckOut(lock)
#define LOCKDEP_CLEAR_LOCKS() OsLockdepClearSpinlocks() #define LOCKDEP_CLEAR_LOCKS() OsLockdepClearSpinlocks()
#define SPIN_LOCK_INITIALIZER(lockName) \/*这段代码看起来是定义了一个自旋锁的初始化器。不同的编译选项将定义不同的初始化器*/ #define SPIN_LOCK_INITIALIZER(lockName) \
{ \ { \
.rawLock = 0U, \ .rawLock = 0U, \
.cpuid = (UINT32)(-1), \ .cpuid = (UINT32)(-1), \
.owner = SPINLOCK_OWNER_INIT, \ .owner = SPINLOCK_OWNER_INIT, \
.name = #lockName, \ .name = #lockName, \
} }
/*当预定义宏为真时，SPIN_LOCK_INITIALIZER宏会被展开为一个结构体初始化器，其中包含了一些成员变量的初始化，包括：
.rawLock：自旋锁的原始锁变量，初始化为0;
.cpuid：持有自旋锁的CPU编号，初始化为-1;
.owner：自旋锁的拥有者，初始化为SPINLOCK_OWNER_INIT；
.name：自旋锁的名称，初始化为锁的名称字符串。
当预定义宏为假时，SPIN_LOCK_INITIALIZER宏将被定义为空。*/
#else #else
#define LOCKDEP_CHECK_IN(lock) #define LOCKDEP_CHECK_IN(lock)
#define LOCKDEP_RECORD(lock) #define LOCKDEP_RECORD(lock)
@ -78,8 +72,7 @@ extern "C" {
.rawLock = 0U, \ .rawLock = 0U, \
} }
#endif #endif
/*
定义了一些空的宏，如LOCKDEP_CHECK_IN、LOCKDEP_RECORD、LOCKDEP_CHECK_OUT和LOCKDEP_CLEAR_LOCKS，这些宏在预定义的宏为假时会被定义为空操作。*/
/** /**
* @ingroup los_spinlock * @ingroup los_spinlock
* <ul> * <ul>
@ -94,8 +87,8 @@ extern "C" {
* obtained. For time-consuming operation, the mutex lock can be used instead of spinlock.</li> * obtained. For time-consuming operation, the mutex lock can be used instead of spinlock.</li>
* </ul> * </ul>
*/ */
#define SPIN_LOCK_INIT(lock) SPIN_LOCK_S lock = SPIN_LOCK_INITIALIZER(lock)/*这段代码定义了一个宏SPIN_LOCK_INIT，用于将输入参数lock定义为自旋锁，并静态地初始化自旋锁*/ #define SPIN_LOCK_INIT(lock) SPIN_LOCK_S lock = SPIN_LOCK_INITIALIZER(lock)
/*该宏主要用于定义和初始化自旋锁，用于保护对共享资源的短时间访问。在使用自旋锁时，需要注意避免使用在耗时较长的操作上，以免影响整体系统性能*/
/** /**
* @ingroup los_spinlock * @ingroup los_spinlock
* Define the structure of spinlock. * Define the structure of spinlock.
@ -111,13 +104,8 @@ struct Spinlock {
const CHAR *name; /**< the lock owner's task name. It is defined only when const CHAR *name; /**< the lock owner's task name. It is defined only when
LOSCFG_KERNEL_SMP_LOCKDEP is defined. */ LOSCFG_KERNEL_SMP_LOCKDEP is defined. */
#endif #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 #ifdef LOSCFG_KERNEL_SMP
/** /**
* @ingroup los_spinlock * @ingroup los_spinlock
@ -158,14 +146,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinLock(SPIN_LOCK_S *lock)
LOCKDEP_CHECK_IN(lock); LOCKDEP_CHECK_IN(lock);
ArchSpinLock(&lock->rawLock); ArchSpinLock(&lock->rawLock);
LOCKDEP_RECORD(lock); 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 * @ingroup los_spinlock
@ -204,11 +185,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE INT32 LOS_SpinTrylock(SPIN_LOCK_S *lock)
} }
return ret; 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 * @ingroup los_spinlock
@ -238,10 +215,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinUnlock(SPIN_LOCK_S *lock)
/* restore the scheduler flag */ /* restore the scheduler flag */
LOS_TaskUnlock(); LOS_TaskUnlock();
}/*这段代码实现了自旋锁的解锁操作，函数名称为LOS_SpinUnlock。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要解锁的自旋锁。*/ }
/*在函数内部，首先调用LOCKDEP_CHECK_OUT宏用于检查并记录锁依赖关系，并最终调用ArchSpinUnlock函数对自旋锁进行解锁操作。
然后，通过调用LOS_TaskUnlock函数恢复调度器的状态，允许任务切换。*/
/** /**
* @ingroup los_spinlock * @ingroup los_spinlock
@ -275,11 +249,8 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinLockSave(SPIN_LOCK_S *lock, UI
{ {
*intSave = LOS_IntLock(); *intSave = LOS_IntLock();
LOS_SpinLock(lock); LOS_SpinLock(lock);
}/*这段代码实现了自旋锁的带保存中断状态的加锁操作，函数名称为LOS_SpinLockSave。它接收一个类型为SPIN_LOCK_S*的指针参数lock， }
表示要加锁的自旋锁；另外还接收一个类型为UINT32*的指针参数intSave，表示用于保存中断状态的指针*/
/*在函数内部，首先调用LOS_IntLock函数禁用所有中断，并将禁用前的中断状态保存到intSave指向的地址中。然后调用LOS_SpinLock函数对自旋锁进行加锁操作。
*/
/** /**
* @ingroup los_spinlock * @ingroup los_spinlock
* @brief Unlock the spinlock and restore the interrupt flag. * @brief Unlock the spinlock and restore the interrupt flag.
@ -308,11 +279,8 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinUnlockRestore(SPIN_LOCK_S *loc
{ {
LOS_SpinUnlock(lock); LOS_SpinUnlock(lock);
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
}/*这段代码实现了自旋锁的解锁操作，并恢复中断状态。函数名称为LOS_SpinUnlockRestore。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要解锁的自旋锁； }
另外还接收一个类型为UINT32的参数intSave，表示要恢复的中断状态。*/
/*在函数内部，首先调用LOS_SpinUnlock函数对自旋锁进行解锁操作，然后调用LOS_IntRestore函数恢复中断状态，参数为之前保存的中断状态intSave。
需要注意的是，该函数只能在调用LOS_SpinLockSave函数之后调用，并且传入的intSave参数应该是由LOS_SpinLockSave函数返回的中断状态保存值*/
/** /**
* @ingroup los_spinlock * @ingroup los_spinlock
* @brief Check if holding the spinlock. * @brief Check if holding the spinlock.
@ -337,9 +305,8 @@ 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) LITE_OS_SEC_ALW_INLINE STATIC INLINE BOOL LOS_SpinHeld(const SPIN_LOCK_S *lock)
{ {
return (lock->rawLock != 0); return (lock->rawLock != 0);
}/*这段代码实现了检查自旋锁是否被持有的功能。函数名称为LOS_SpinHeld。它接收一个类型为SPIN_LOCK_S*的指针参数lock，表示要检查的自旋锁*/ }
/*在函数内部，通过判断自旋锁的rawLock成员变量是否为0来确定自旋锁是否被持有。如果rawLock不为0，则表示自旋锁被持有，返回TRUE；否则，表示自旋锁未被持有，返回FALSE*/
/** /**
* @ingroup los_spinlock * @ingroup los_spinlock
* @brief Spinlock dynamic initialization. * @brief Spinlock dynamic initialization.
@ -372,13 +339,8 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinInit(SPIN_LOCK_S *lock)
lock->owner = SPINLOCK_OWNER_INIT; lock->owner = SPINLOCK_OWNER_INIT;
lock->name = "spinlock"; lock->name = "spinlock";
#endif #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 #else
/* /*
@ -423,15 +385,7 @@ LITE_OS_SEC_ALW_INLINE STATIC INLINE VOID LOS_SpinInit(SPIN_LOCK_S *lock)
{ {
(VOID)lock; (VOID)lock;
} }
/*上述代码中，是对于非多处理器系统的处理。这些函数并不实际处理自旋锁，而是为了统一代码的编写，以方便驱动程序、供应商等进行开发。
以下是这些函数的说明：
LOS_SpinLock：空函数，不执行任何操作。
LOS_SpinTrylock：空函数，不执行任何操作，并返回LOS_OK。
LOS_SpinUnlock：空函数，不执行任何操作。
LOS_SpinLockSave：空函数，不执行任何操作，并通过指针参数intSave保存中断状态。
LOS_SpinUnlockRestore：空函数，不执行任何操作，并使用参数intSave恢复中断状态。
LOS_SpinHeld：空函数，不执行任何操作，并返回TRUE表示自旋锁已被持有。
LOS_SpinInit：空函数，不执行任何操作。*/
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save