From eb9a4bef9785840aa5dd87640aeb0c7d01d8c956 Mon Sep 17 00:00:00 2001
From: weitong <494475907@qq.com>
Date: Mon, 4 Dec 2023 20:01:27 +0800
Subject: [PATCH] weitong
---
core/los_task.c | 688 +++++++++++++++++++++++++-----------------------
1 file changed, 356 insertions(+), 332 deletions(-)
diff --git a/core/los_task.c b/core/los_task.c
index 67b7ab6..e33ccac 100644
--- a/core/los_task.c
+++ b/core/los_task.c
@@ -66,34 +66,38 @@
#error "task maxnum cannot be zero"
#endif /* LOSCFG_BASE_CORE_TSK_LIMIT <= 0 */
-LITE_OS_SEC_BSS LosTaskCB *g_taskCBArray;
-LITE_OS_SEC_BSS LOS_DL_LIST g_losFreeTask;
-LITE_OS_SEC_BSS LOS_DL_LIST g_taskRecycleList;
-LITE_OS_SEC_BSS UINT32 g_taskMaxNum;
-LITE_OS_SEC_BSS UINT32 g_taskScheduled; /* one bit for each cores */
-LITE_OS_SEC_BSS EVENT_CB_S g_resourceEvent;
-/* spinlock for task module, only available on SMP mode */
-LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_taskSpin);
-
+ // ȫ�ֱ�������
+LITE_OS_SEC_BSS LosTaskCB* g_taskCBArray; // ������ƿ�����
+LITE_OS_SEC_BSS LOS_DL_LIST g_losFreeTask; // ���������б�
+LITE_OS_SEC_BSS LOS_DL_LIST g_taskRecycleList; // �����������б�
+LITE_OS_SEC_BSS UINT32 g_taskMaxNum; // �����������
+LITE_OS_SEC_BSS UINT32 g_taskScheduled; // ������ȱ�־��ÿ������һ��λ
+LITE_OS_SEC_BSS EVENT_CB_S g_resourceEvent; // ��Դ�¼����ƿ�
+LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_taskSpin); // ����ģ���������
+
+// �����ú�������
STATIC VOID OsConsoleIDSetHook(UINT32 param1,
- UINT32 param2) __attribute__((weakref("OsSetConsoleID")));
+ UINT32 param2) __attribute__((weakref("OsSetConsoleID")));
+// �궨��
#define OS_CHECK_TASK_BLOCK (OS_TASK_STATUS_DELAY | \
OS_TASK_STATUS_PENDING | \
OS_TASK_STATUS_SUSPENDED)
-/* temp task blocks for booting procedure */
+// ��ʱ�����������������
LITE_OS_SEC_BSS STATIC LosTaskCB g_mainTask[LOSCFG_KERNEL_CORE_NUM];
-LosTaskCB *OsGetMainTask()
+// ��ȡ��������ƿ�
+LosTaskCB* OsGetMainTask()
{
- return (LosTaskCB *)(g_mainTask + ArchCurrCpuid());
+ return (LosTaskCB*)(g_mainTask + ArchCurrCpuid());
}
+// ����������ij�ʼ״̬
VOID OsSetMainTask()
{
UINT32 i;
- CHAR *name = "osMain";
+ CHAR* name = "osMain";
for (i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
g_mainTask[i].taskStatus = OS_TASK_STATUS_UNUSED;
@@ -111,141 +115,143 @@ VOID OsSetMainTask()
LITE_OS_SEC_TEXT WEAK VOID OsIdleTask(VOID)
{
while (1) {
- WFI;
+ WFI; // �ȴ��ж�ָ������������ڵ���״̬��ֱ�����յ��ж��ź�
}
}
-STATIC INLINE VOID OsInsertTCBToFreeList(LosTaskCB *taskCB)
+STATIC INLINE VOID OsInsertTCBToFreeList(LosTaskCB* taskCB)
{
UINT32 taskID = taskCB->taskID;
- (VOID)memset_s(taskCB, sizeof(LosTaskCB), 0, sizeof(LosTaskCB));
+ (VOID)memset_s(taskCB, sizeof(LosTaskCB), 0, sizeof(LosTaskCB)); // ���������ƿ�
taskCB->taskID = taskID;
- taskCB->taskStatus = OS_TASK_STATUS_UNUSED;
- taskCB->processID = OS_INVALID_VALUE;
- LOS_ListAdd(&g_losFreeTask, &taskCB->pendList);
+ taskCB->taskStatus = OS_TASK_STATUS_UNUSED; // ��������״̬Ϊδʹ��
+ taskCB->processID = OS_INVALID_VALUE; // ���ý���IDΪ��Чֵ
+ LOS_ListAdd(&g_losFreeTask, &taskCB->pendList); // ��������ƿ����ӵ����������б���
}
-LITE_OS_SEC_TEXT_INIT VOID OsTaskJoinPostUnsafe(LosTaskCB *taskCB)
+LITE_OS_SEC_TEXT_INIT VOID OsTaskJoinPostUnsafe(LosTaskCB* taskCB)
{
- LosTaskCB *resumedTask = NULL;
+ LosTaskCB* resumedTask = NULL;
- if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
+ if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) { // ����������pthread_join��־
if (!LOS_ListEmpty(&taskCB->joinList)) {
- resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(taskCB->joinList)));
- OsTaskWakeClearPendMask(resumedTask);
- OsSchedTaskWake(resumedTask);
+ resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(taskCB->joinList))); // ��ȡ��һ���ȴ��������������ƿ�
+ OsTaskWakeClearPendMask(resumedTask); // �������ĵȴ���־
+ OsSchedTaskWake(resumedTask); // ���ѵȴ�������
}
- taskCB->taskStatus &= ~OS_TASK_FLAG_PTHREAD_JOIN;
+ taskCB->taskStatus &= ~OS_TASK_FLAG_PTHREAD_JOIN; // ���pthread_join��־
}
- taskCB->taskStatus |= OS_TASK_STATUS_EXIT;
+ taskCB->taskStatus |= OS_TASK_STATUS_EXIT; // ��������״̬Ϊ�˳�
}
-LITE_OS_SEC_TEXT UINT32 OsTaskJoinPendUnsafe(LosTaskCB *taskCB)
+LITE_OS_SEC_TEXT UINT32 OsTaskJoinPendUnsafe(LosTaskCB* taskCB)
{
- LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
- if (!(processCB->processStatus & OS_PROCESS_STATUS_RUNNING)) {
- return LOS_EPERM;
+ LosProcessCB* processCB = OS_PCB_FROM_PID(taskCB->processID); // ��ȡ�����������̵Ľ��̿��ƿ�
+ if (!(processCB->processStatus & OS_PROCESS_STATUS_RUNNING)) { // �������״̬��������״̬
+ return LOS_EPERM; // ���ش����룬��ʾû��Ȩ��
}
- if (taskCB->taskStatus & OS_TASK_STATUS_INIT) {
- return LOS_EINVAL;
+ if (taskCB->taskStatus & OS_TASK_STATUS_INIT) { // �������״̬Ϊ��ʼ��״̬
+ return LOS_EINVAL; // ���ش����룬��ʾ������Ч
}
- if ((taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) && LOS_ListEmpty(&taskCB->joinList)) {
- OsTaskWaitSetPendMask(OS_TASK_WAIT_JOIN, taskCB->taskID, LOS_WAIT_FOREVER);
- return OsSchedTaskWait(&taskCB->joinList, LOS_WAIT_FOREVER, TRUE);
- } else if (taskCB->taskStatus & OS_TASK_STATUS_EXIT) {
- return LOS_OK;
+ if ((taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) && LOS_ListEmpty(&taskCB->joinList)) { // ����������pthread_join��־�ҵȴ��б�Ϊ��
+ OsTaskWaitSetPendMask(OS_TASK_WAIT_JOIN, taskCB->taskID, LOS_WAIT_FOREVER); // ��������ĵȴ���־
+ return OsSchedTaskWait(&taskCB->joinList, LOS_WAIT_FOREVER, TRUE); // ���������ȴ�״̬�����ȴ�������
+ }
+ else if (taskCB->taskStatus & OS_TASK_STATUS_EXIT) { // �������״̬Ϊ�˳�״̬
+ return LOS_OK; // ���سɹ���
}
- return LOS_EINVAL;
+ return LOS_EINVAL; // ���ش����룬��ʾ������Ч
}
-LITE_OS_SEC_TEXT UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB)
+LITE_OS_SEC_TEXT UINT32 OsTaskSetDetachUnsafe(LosTaskCB* taskCB)
{
- LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
- if (!(processCB->processStatus & OS_PROCESS_STATUS_RUNNING)) {
- return LOS_EPERM;
+ LosProcessCB* processCB = OS_PCB_FROM_PID(taskCB->processID); // ��ȡ�����������̵Ľ��̿��ƿ�
+ if (!(processCB->processStatus & OS_PROCESS_STATUS_RUNNING)) { // �������״̬��������״̬
+ return LOS_EPERM; // ���ش����룬��ʾû��Ȩ��
}
- if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
- if (LOS_ListEmpty(&(taskCB->joinList))) {
- LOS_ListDelete(&(taskCB->joinList));
- taskCB->taskStatus &= ~OS_TASK_FLAG_PTHREAD_JOIN;
- taskCB->taskStatus |= OS_TASK_FLAG_DETACHED;
- return LOS_OK;
+ if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) { // ����������pthread_join��־
+ if (LOS_ListEmpty(&(taskCB->joinList))) { // ����ȴ��б�Ϊ��
+ LOS_ListDelete(&(taskCB->joinList)); // �ӵȴ��б���ɾ������
+ taskCB->taskStatus &= ~OS_TASK_FLAG_PTHREAD_JOIN; // ���pthread_join��־
+ taskCB->taskStatus |= OS_TASK_FLAG_DETACHED; // ��������Ϊ����״̬
+ return LOS_OK; // ���سɹ���
}
/* This error code has a special purpose and is not allowed to appear again on the interface */
- return LOS_ESRCH;
+ return LOS_ESRCH; // ���ش����룬��ʾû���ҵ�
}
- return LOS_EINVAL;
+ return LOS_EINVAL; // ���ش����룬��ʾ������Ч
}
+
LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
{
UINT32 index;
UINT32 size;
UINT32 ret;
- g_taskMaxNum = LOSCFG_BASE_CORE_TSK_LIMIT;
- size = (g_taskMaxNum + 1) * sizeof(LosTaskCB);
+ g_taskMaxNum = LOSCFG_BASE_CORE_TSK_LIMIT; // ��ȡ������������
+ size = (g_taskMaxNum + 1) * sizeof(LosTaskCB); // ����������ƿ�����Ĵ�С
/*
* This memory is resident memory and is used to save the system resources
* of task control block and will not be freed.
*/
- g_taskCBArray = (LosTaskCB *)LOS_MemAlloc(m_aucSysMem0, size);
+ g_taskCBArray = (LosTaskCB*)LOS_MemAlloc(m_aucSysMem0, size); // ����������ƿ�������ڴ�
if (g_taskCBArray == NULL) {
- ret = LOS_ERRNO_TSK_NO_MEMORY;
+ ret = LOS_ERRNO_TSK_NO_MEMORY; // �����ڴ�ʧ�ܣ����ش�����
goto EXIT;
}
- (VOID)memset_s(g_taskCBArray, size, 0, size);
+ (VOID)memset_s(g_taskCBArray, size, 0, size); // ���������ƿ�������ڴ�
- LOS_ListInit(&g_losFreeTask);
- LOS_ListInit(&g_taskRecycleList);
+ LOS_ListInit(&g_losFreeTask); // ��ʼ�����������б�
+ LOS_ListInit(&g_taskRecycleList); // ��ʼ����������б�
for (index = 0; index < g_taskMaxNum; index++) {
- g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;
- g_taskCBArray[index].taskID = index;
- LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList);
+ g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED; // ��������״̬Ϊδʹ��
+ g_taskCBArray[index].taskID = index; // ��������ID
+ LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList); // ��������ƿ����ӵ����������б���
}
- ret = OsSchedInit();
+ ret = OsSchedInit(); // ��������ʼ��
EXIT:
if (ret != LOS_OK) {
- PRINT_ERR("OsTaskInit error\n");
+ PRINT_ERR("OsTaskInit error\n"); // ��ӡ������Ϣ
}
- return ret;
+ return ret; // ���س�ʼ�����
}
UINT32 OsGetIdleTaskId(VOID)
{
- Percpu *perCpu = OsPercpuGet();
- return perCpu->idleTaskID;
+ Percpu* perCpu = OsPercpuGet(); // ��ȡ��ǰCPU��˽������
+ return perCpu->idleTaskID; // ���ؿ��������ID
}
LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
{
UINT32 ret;
TSK_INIT_PARAM_S taskInitParam;
- Percpu *perCpu = OsPercpuGet();
- UINT32 *idleTaskID = &perCpu->idleTaskID;
-
- (VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
- taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsIdleTask;
- taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE;
- taskInitParam.pcName = "Idle";
- taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;
- taskInitParam.processID = OsGetIdleProcessID();
+ Percpu* perCpu = OsPercpuGet(); // ��ȡ��ǰCPU��˽������
+ UINT32* idleTaskID = &perCpu->idleTaskID; // ��ȡ���������ID
+
+ (VOID)memset_s((VOID*)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S)); // ��������ʼ�������ṹ��
+ taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsIdleTask; // ����������ں���ΪOsIdleTask
+ taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE; // ���������ջ��С
+ taskInitParam.pcName = "Idle"; // ������������
+ taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST; // �����������ȼ�Ϊ������ȼ�
+ taskInitParam.processID = OsGetIdleProcessID(); // ��ȡ���������������̵�ID
#ifdef LOSCFG_KERNEL_SMP
- taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());
+ taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid()); // ���������CPU��������
#endif
- ret = LOS_TaskCreateOnly(idleTaskID, &taskInitParam);
- LosTaskCB *idleTask = OS_TCB_FROM_TID(*idleTaskID);
- idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;
- OsSchedSetIdleTaskSchedParam(idleTask);
+ ret = LOS_TaskCreateOnly(idleTaskID, &taskInitParam); // ������������
+ LosTaskCB* idleTask = OS_TCB_FROM_TID(*idleTaskID); // ��ȡ���������������ƿ�
+ idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK; // ���ÿ�������ı�־Ϊϵͳ����
+ OsSchedSetIdleTaskSchedParam(idleTask); // ���ÿ�������ĵ��Ȳ���
- return ret;
+ return ret; // ���ش������
}
/*
@@ -254,167 +260,169 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
*/
LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
{
- LosTaskCB *runTask = OsCurrTaskGet();
+ LosTaskCB* runTask = OsCurrTaskGet(); // ��ȡ��ǰ���е�������ƿ�
if (runTask == NULL) {
- return LOS_ERRNO_TSK_ID_INVALID;
+ return LOS_ERRNO_TSK_ID_INVALID; // �����ȡ��������ƿ�Ϊ�գ����ش�����
}
- return runTask->taskID;
+ return runTask->taskID; // ���ص�ǰ�����ID
}
-LITE_OS_SEC_TEXT VOID OsTaskToExit(LosTaskCB *taskCB, UINT32 status)
+LITE_OS_SEC_TEXT VOID OsTaskToExit(LosTaskCB* taskCB, UINT32 status)
{
UINT32 intSave;
- LosProcessCB *runProcess = OS_PCB_FROM_PID(taskCB->processID);
- LosTaskCB *mainTask = OS_TCB_FROM_TID(runProcess->threadGroupID);
+ LosProcessCB* runProcess = OS_PCB_FROM_PID(taskCB->processID); // ��ȡ�����������̵Ľ��̿��ƿ�
+ LosTaskCB* mainTask = OS_TCB_FROM_TID(runProcess->threadGroupID); // ��ȡ���̵����߳�������ƿ�
if (mainTask == taskCB) {
- OsTaskExitGroup(status);
+ OsTaskExitGroup(status); // ��������ǽ��̵����̣߳����˳���������
}
- SCHEDULER_LOCK(intSave);
+ SCHEDULER_LOCK(intSave); // ����������
if (runProcess->threadNumber == 1) { /* 1: The last task of the process exits */
- SCHEDULER_UNLOCK(intSave);
- (VOID)OsProcessExit(taskCB, status);
+ SCHEDULER_UNLOCK(intSave); // ����������
+ (VOID)OsProcessExit(taskCB, status); // ���������һ�������˳�ʱ�����ý����˳�����
return;
}
/* The thread being killed must be able to exit automatically and will have the detached property */
- OsTaskJoinPostUnsafe(taskCB);
+ OsTaskJoinPostUnsafe(taskCB); // ����ɱ�����߳�����Ϊ���Զ��˳������з�������
if (taskCB->taskStatus & (OS_TASK_FLAG_DETACHED | OS_TASK_FLAG_EXIT_KILL)) {
- UINT32 ret = OsTaskDeleteUnsafe(taskCB, status, intSave);
- LOS_Panic("Task delete failed! ERROR : 0x%x\n", ret);
+ UINT32 ret = OsTaskDeleteUnsafe(taskCB, status, intSave); // ���������з������Ի��Ϊ�˳�ɱ��״̬����ɾ������
+ LOS_Panic("Task delete failed! ERROR : 0x%x\n", ret); // ����ɾ��ʧ�ܣ���ӡ������Ϣ
}
- OsSchedResched();
- SCHEDULER_UNLOCK(intSave);
+ OsSchedResched(); // �����������µ���
+ SCHEDULER_UNLOCK(intSave); // ����������
return;
}
+
/*
* Description : All task entry
* Input : taskID --- The ID of the task to be run
*/
LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
{
- LosTaskCB *taskCB = NULL;
+ LosTaskCB* taskCB = NULL;
- LOS_ASSERT(!OS_TID_CHECK_INVALID(taskID));
+ LOS_ASSERT(!OS_TID_CHECK_INVALID(taskID)); // ��������ID������
/*
* task scheduler needs to be protected throughout the whole process
* from interrupt and other cores. release task spinlock and enable
* interrupt in sequence at the task entry.
*/
- LOS_SpinUnlock(&g_taskSpin);
- (VOID)LOS_IntUnLock();
+ LOS_SpinUnlock(&g_taskSpin); // �ͷ�����������
+ (VOID)LOS_IntUnLock(); // �����ж�
- taskCB = OS_TCB_FROM_TID(taskID);
+ taskCB = OS_TCB_FROM_TID(taskID); // ��������ID��ȡ������ƿ�
taskCB->joinRetval = taskCB->taskEntry(taskCB->args[0], taskCB->args[1],
- taskCB->args[2], taskCB->args[3]); /* 2 & 3: just for args array index */
+ taskCB->args[2], taskCB->args[3]); /* 2 & 3: just for args array index */
if (taskCB->taskStatus & OS_TASK_FLAG_DETACHED) {
taskCB->joinRetval = 0;
}
- OsTaskToExit(taskCB, 0);
+ OsTaskToExit(taskCB, 0); // ����ִ����Ϻ��˳�
}
-LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
- TSK_INIT_PARAM_S *initParam, VOID **pool)
+LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32* taskID,
+ TSK_INIT_PARAM_S* initParam, VOID** pool)
{
- LosProcessCB *process = NULL;
+ LosProcessCB* process = NULL;
UINT32 poolSize = OS_SYS_MEM_SIZE;
- *pool = (VOID *)m_aucSysMem1;
+ *pool = (VOID*)m_aucSysMem1;
if (taskID == NULL) {
- return LOS_ERRNO_TSK_ID_INVALID;
+ return LOS_ERRNO_TSK_ID_INVALID; // ����ID��Ч
}
if (initParam == NULL) {
- return LOS_ERRNO_TSK_PTR_NULL;
+ return LOS_ERRNO_TSK_PTR_NULL; // ��ʼ������Ϊ��
}
- process = OS_PCB_FROM_PID(initParam->processID);
+ process = OS_PCB_FROM_PID(initParam->processID); // ���ݽ���ID��ȡ���̿��ƿ�
if (process->processMode > OS_USER_MODE) {
- return LOS_ERRNO_TSK_ID_INVALID;
+ return LOS_ERRNO_TSK_ID_INVALID; // ����ģʽ��Ч
}
if (!OsProcessIsUserMode(process)) {
if (initParam->pcName == NULL) {
- return LOS_ERRNO_TSK_NAME_EMPTY;
+ return LOS_ERRNO_TSK_NAME_EMPTY; // ����������
}
}
if (initParam->pfnTaskEntry == NULL) {
- return LOS_ERRNO_TSK_ENTRY_NULL;
+ return LOS_ERRNO_TSK_ENTRY_NULL; // ������ں���Ϊ��
}
if (initParam->usTaskPrio > OS_TASK_PRIORITY_LOWEST) {
- return LOS_ERRNO_TSK_PRIOR_ERROR;
+ return LOS_ERRNO_TSK_PRIOR_ERROR; // �������ȼ�����
}
if (initParam->uwStackSize > poolSize) {
- return LOS_ERRNO_TSK_STKSZ_TOO_LARGE;
+ return LOS_ERRNO_TSK_STKSZ_TOO_LARGE; // �����ջ��С����
}
if (initParam->uwStackSize == 0) {
- initParam->uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
+ initParam->uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE; // ��������ջ��СΪ0��������ΪĬ�ϴ�С
}
- initParam->uwStackSize = (UINT32)ALIGN(initParam->uwStackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
+ initParam->uwStackSize = (UINT32)ALIGN(initParam->uwStackSize, LOSCFG_STACK_POINT_ALIGN_SIZE); // �������ջ��С���ж���
if (initParam->uwStackSize < LOS_TASK_MIN_STACK_SIZE) {
- return LOS_ERRNO_TSK_STKSZ_TOO_SMALL;
+ return LOS_ERRNO_TSK_STKSZ_TOO_SMALL; // �����ջ��С��С
}
- return LOS_OK;
+ return LOS_OK; // �������ͨ��
}
-LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskStackAlloc(VOID **topStack, UINT32 stackSize, VOID *pool)
+LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskStackAlloc(VOID** topStack, UINT32 stackSize, VOID* pool)
{
- *topStack = (VOID *)LOS_MemAllocAlign(pool, stackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
+ *topStack = (VOID*)LOS_MemAllocAlign(pool, stackSize, LOSCFG_STACK_POINT_ALIGN_SIZE); // ���������ջ�ڴ�
}
-STATIC INLINE UINT32 OsTaskSyncCreate(LosTaskCB *taskCB)
+STATIC INLINE UINT32 OsTaskSyncCreate(LosTaskCB* taskCB)
{
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
- UINT32 ret = LOS_SemCreate(0, &taskCB->syncSignal);
+ UINT32 ret = LOS_SemCreate(0, &taskCB->syncSignal); // ��������ͬ���ź���
if (ret != LOS_OK) {
- return LOS_ERRNO_TSK_MP_SYNC_RESOURCE;
+ return LOS_ERRNO_TSK_MP_SYNC_RESOURCE; // ����ͬ����Դ����ʧ��
}
#else
(VOID)taskCB;
#endif
- return LOS_OK;
+ return LOS_OK; // ����ͬ�������ɹ�
}
STATIC INLINE VOID OsTaskSyncDestroy(UINT32 syncSignal)
{
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
- (VOID)LOS_SemDelete(syncSignal);
+ (VOID)LOS_SemDelete(syncSignal); // ɾ������ͬ���ź���
#else
(VOID)syncSignal;
#endif
}
-LITE_OS_SEC_TEXT UINT32 OsTaskSyncWait(const LosTaskCB *taskCB)
+
+LITE_OS_SEC_TEXT UINT32 OsTaskSyncWait(const LosTaskCB* taskCB)
{
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
UINT32 ret = LOS_OK;
- LOS_ASSERT(LOS_SpinHeld(&g_taskSpin));
- LOS_SpinUnlock(&g_taskSpin);
+ LOS_ASSERT(LOS_SpinHeld(&g_taskSpin)); // ���������������ѳ���
+ LOS_SpinUnlock(&g_taskSpin); // �ͷ�����������
/*
* gc soft timer works every OS_MP_GC_PERIOD period, to prevent this timer
* triggered right at the timeout has reached, we set the timeout as double
* of the gc peroid.
*/
if (LOS_SemPend(taskCB->syncSignal, OS_MP_GC_PERIOD * 2) != LOS_OK) {
- ret = LOS_ERRNO_TSK_MP_SYNC_FAILED;
+ ret = LOS_ERRNO_TSK_MP_SYNC_FAILED; // ����ͬ���ȴ�ʧ��
}
- LOS_SpinLock(&g_taskSpin);
+ LOS_SpinLock(&g_taskSpin); // ��ȡ����������
return ret;
#else
@@ -423,10 +431,10 @@ LITE_OS_SEC_TEXT UINT32 OsTaskSyncWait(const LosTaskCB *taskCB)
#endif
}
-STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB *taskCB)
+STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB* taskCB)
{
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
- (VOID)OsSemPostUnsafe(taskCB->syncSignal, NULL);
+ (VOID)OsSemPostUnsafe(taskCB->syncSignal, NULL); // ��������ͬ���ź���
#else
(VOID)taskCB;
#endif
@@ -434,39 +442,39 @@ STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB *taskCB)
STATIC VOID OsTaskKernelResourcesToFree(UINT32 syncSignal, UINTPTR topOfStack)
{
- VOID *poolTmp = (VOID *)m_aucSysMem1;
+ VOID* poolTmp = (VOID*)m_aucSysMem1;
- OsTaskSyncDestroy(syncSignal);
+ OsTaskSyncDestroy(syncSignal); // ��������ͬ���ź���
- (VOID)LOS_MemFree(poolTmp, (VOID *)topOfStack);
+ (VOID)LOS_MemFree(poolTmp, (VOID*)topOfStack); // �ͷ������ջ�ڴ�
}
LITE_OS_SEC_TEXT VOID OsTaskCBRecycleToFree()
{
- LosTaskCB *taskCB = NULL;
+ LosTaskCB* taskCB = NULL;
UINT32 intSave;
SCHEDULER_LOCK(intSave);
while (!LOS_ListEmpty(&g_taskRecycleList)) {
- taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_taskRecycleList));
- LOS_ListDelete(&taskCB->pendList);
+ taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_taskRecycleList)); // ����������б��л�ȡ������ƿ�
+ LOS_ListDelete(&taskCB->pendList); // �ӻ����б����Ƴ�������ƿ�
SCHEDULER_UNLOCK(intSave);
- OsTaskResourcesToFree(taskCB);
+ OsTaskResourcesToFree(taskCB); // �ͷ�������Դ
SCHEDULER_LOCK(intSave);
}
SCHEDULER_UNLOCK(intSave);
}
-LITE_OS_SEC_TEXT VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
+LITE_OS_SEC_TEXT VOID OsTaskResourcesToFree(LosTaskCB* taskCB)
{
UINT32 syncSignal = LOSCFG_BASE_IPC_SEM_LIMIT;
UINT32 intSave;
UINTPTR topOfStack;
#ifdef LOSCFG_KERNEL_VM
- LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+ LosProcessCB* processCB = OS_PCB_FROM_PID(taskCB->processID);
if (OsProcessIsUserMode(processCB) && (taskCB->userMapBase != 0)) {
SCHEDULER_LOCK(intSave);
UINT32 mapBase = (UINTPTR)taskCB->userMapBase;
@@ -476,10 +484,10 @@ LITE_OS_SEC_TEXT VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
SCHEDULER_UNLOCK(intSave);
LOS_ASSERT(!(processCB->vmSpace == NULL));
- UINT32 ret = OsUnMMap(processCB->vmSpace, (UINTPTR)mapBase, mapSize);
+ UINT32 ret = OsUnMMap(processCB->vmSpace, (UINTPTR)mapBase, mapSize); // ȡ��ӳ���û��ڴ�
if ((ret != LOS_OK) && (mapBase != 0) && !(processCB->processStatus & OS_PROCESS_STATUS_INIT)) {
PRINT_ERR("process(%u) ummap user task(%u) stack failed! mapbase: 0x%x size :0x%x, error: %d\n",
- processCB->processID, taskCB->taskID, mapBase, mapSize, ret);
+ processCB->processID, taskCB->taskID, mapBase, mapSize, ret);
}
#ifdef LOSCFG_KERNEL_LITEIPC
@@ -489,189 +497,197 @@ LITE_OS_SEC_TEXT VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
#endif
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
- topOfStack = taskCB->topOfStack;
+ topOfStack = taskCB->topOfStack; // ��ȡ�����ջ��ջ����ַ
taskCB->topOfStack = 0;
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
- syncSignal = taskCB->syncSignal;
+ syncSignal = taskCB->syncSignal; // ��ȡ����ͬ���ź���
taskCB->syncSignal = LOSCFG_BASE_IPC_SEM_LIMIT;
#endif
- OsTaskKernelResourcesToFree(syncSignal, topOfStack);
+ OsTaskKernelResourcesToFree(syncSignal, topOfStack); // �ͷ������ں���Դ
SCHEDULER_LOCK(intSave);
- OsClearSigInfoTmpList(&(taskCB->sig));
- OsInsertTCBToFreeList(taskCB);
+ OsClearSigInfoTmpList(&(taskCB->sig)); // ��������ź���Ϣ��ʱ�б�
+ OsInsertTCBToFreeList(taskCB); // ��������ƿ���뵽�����б���
SCHEDULER_UNLOCK(intSave);
}
return;
}
-LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInitBase(LosTaskCB *taskCB,
- const VOID *stackPtr,
- const VOID *topStack,
- const TSK_INIT_PARAM_S *initParam)
+
+LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInitBase(LosTaskCB* taskCB,
+ const VOID* stackPtr,
+ const VOID* topStack,
+ const TSK_INIT_PARAM_S* initParam)
{
- taskCB->stackPointer = (VOID *)stackPtr;
- taskCB->args[0] = initParam->auwArgs[0]; /* 0~3: just for args array index */
- taskCB->args[1] = initParam->auwArgs[1];
- taskCB->args[2] = initParam->auwArgs[2];
- taskCB->args[3] = initParam->auwArgs[3];
- taskCB->topOfStack = (UINTPTR)topStack;
- taskCB->stackSize = initParam->uwStackSize;
- taskCB->priority = initParam->usTaskPrio;
- taskCB->taskEntry = initParam->pfnTaskEntry;
- taskCB->signal = SIGNAL_NONE;
+ taskCB->stackPointer = (VOID*)stackPtr; // ��������Ķ�ջָ��
+ taskCB->args[0] = initParam->auwArgs[0]; /* 0~3: just for args array index */ // ��������IJ���
+ taskCB->args[1] = initParam->auwArgs[1];
+ taskCB->args[2] = initParam->auwArgs[2];
+ taskCB->args[3] = initParam->auwArgs[3];
+ taskCB->topOfStack = (UINTPTR)topStack; // ���������ջ��ջ����ַ
+ taskCB->stackSize = initParam->uwStackSize; // ���������ջ�Ĵ�С
+ taskCB->priority = initParam->usTaskPrio; // ������������ȼ�
+ taskCB->taskEntry = initParam->pfnTaskEntry; // �����������ں���
+ taskCB->signal = SIGNAL_NONE; // ��ʼ��������ź�
#ifdef LOSCFG_KERNEL_SMP
- taskCB->currCpu = OS_TASK_INVALID_CPUID;
- taskCB->cpuAffiMask = (initParam->usCpuAffiMask) ?
- initParam->usCpuAffiMask : LOSCFG_KERNEL_CPU_MASK;
+ taskCB->currCpu = OS_TASK_INVALID_CPUID; // ��ʼ����ǰ�����������ڵ�CPU ID
+ taskCB->cpuAffiMask = (initParam->usCpuAffiMask) ?
+ initParam->usCpuAffiMask : LOSCFG_KERNEL_CPU_MASK; // ��ʼ�������CPU��������
#endif
#ifdef LOSCFG_KERNEL_LITEIPC
- LOS_ListInit(&(taskCB->msgListHead));
+ LOS_ListInit(&(taskCB->msgListHead)); // ��ʼ���������Ϣ�б�
#endif
- taskCB->policy = (initParam->policy == LOS_SCHED_FIFO) ? LOS_SCHED_FIFO : LOS_SCHED_RR;
- taskCB->taskStatus = OS_TASK_STATUS_INIT;
+ taskCB->policy = (initParam->policy == LOS_SCHED_FIFO) ? LOS_SCHED_FIFO : LOS_SCHED_RR; // ��������ĵ��Ȳ���
+ taskCB->taskStatus = OS_TASK_STATUS_INIT; // ��ʼ�������״̬
if (initParam->uwResved & OS_TASK_FLAG_DETACHED) {
- taskCB->taskStatus |= OS_TASK_FLAG_DETACHED;
- } else {
- taskCB->taskStatus |= OS_TASK_FLAG_PTHREAD_JOIN;
+ taskCB->taskStatus |= OS_TASK_FLAG_DETACHED; // ���������Ϊ����̬������������ķ�����
+ }
+ else {
+ taskCB->taskStatus |= OS_TASK_FLAG_PTHREAD_JOIN; // �������������pthread join��ǣ�����ʼ������ĵȴ��б�
LOS_ListInit(&taskCB->joinList);
}
- taskCB->futex.index = OS_INVALID_VALUE;
- LOS_ListInit(&taskCB->lockList);
- SET_SORTLIST_VALUE(&taskCB->sortList, OS_SORT_LINK_INVALID_TIME);
+ taskCB->futex.index = OS_INVALID_VALUE; // ��ʼ�������futex����ֵ
+ LOS_ListInit(&taskCB->lockList); // ��ʼ����������б�
+ SET_SORTLIST_VALUE(&taskCB->sortList, OS_SORT_LINK_INVALID_TIME); // ��ʼ���������������
}
-STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam,
- const VOID *stackPtr, const VOID *topStack)
+STATIC UINT32 OsTaskCBInit(LosTaskCB* taskCB, const TSK_INIT_PARAM_S* initParam,
+ const VOID* stackPtr, const VOID* topStack)
{
- UINT32 intSave;
- UINT32 ret;
- UINT32 numCount;
- UINT16 mode;
- LosProcessCB *processCB = NULL;
+ UINT32 intSave; // �����ж�״̬�ı���
+ UINT32 ret; // ��������ֵ
+ UINT32 numCount; // �̼߳���
+ UINT16 mode; // ��������ģʽ
+ LosProcessCB* processCB = NULL; // ���̿��ƿ�ָ��
- OsTaskCBInitBase(taskCB, stackPtr, topStack, initParam);
+ OsTaskCBInitBase(taskCB, stackPtr, topStack, initParam); // ��ʼ��������ƿ�Ļ�����Ϣ
- SCHEDULER_LOCK(intSave);
- processCB = OS_PCB_FROM_PID(initParam->processID);
- taskCB->processID = processCB->processID;
- mode = processCB->processMode;
- LOS_ListTailInsert(&(processCB->threadSiblingList), &(taskCB->threadList));
- if (mode == OS_USER_MODE) {
- taskCB->userArea = initParam->userParam.userArea;
- taskCB->userMapBase = initParam->userParam.userMapBase;
- taskCB->userMapSize = initParam->userParam.userMapSize;
- OsUserTaskStackInit(taskCB->stackPointer, (UINTPTR)taskCB->taskEntry, initParam->userParam.userSP);
+ SCHEDULER_LOCK(intSave); // �رյ������ж�
+
+ processCB = OS_PCB_FROM_PID(initParam->processID); // ���ݽ���ID��ȡ���̿��ƿ�
+ taskCB->processID = processCB->processID; // �������������Ľ���ID
+ mode = processCB->processMode; // ��ȡ���̵�����ģʽ
+ LOS_ListTailInsert(&(processCB->threadSiblingList), &(taskCB->threadList)); // ��������ƿ������̵��߳�������
+
+ if (mode == OS_USER_MODE) { // ��������������û�ģʽ��
+ taskCB->userArea = initParam->userParam.userArea; // ����������û�����
+ taskCB->userMapBase = initParam->userParam.userMapBase; // ����������û�ӳ�����ַ
+ taskCB->userMapSize = initParam->userParam.userMapSize; // ����������û�ӳ���С
+ OsUserTaskStackInit(taskCB->stackPointer, (UINTPTR)taskCB->taskEntry, initParam->userParam.userSP); // ��ʼ���û������ջ
}
- if (!processCB->threadNumber) {
- processCB->threadGroupID = taskCB->taskID;
+ if (!processCB->threadNumber) { // ������̵��߳���Ϊ0
+ processCB->threadGroupID = taskCB->taskID; // ���ý��̵��߳���IDΪ��ǰ����ID
}
- processCB->threadNumber++;
+ processCB->threadNumber++; // �߳�����1
- numCount = processCB->threadCount;
- processCB->threadCount++;
- SCHEDULER_UNLOCK(intSave);
+ numCount = processCB->threadCount; // ��ȡ���̵��̼߳���
+ processCB->threadCount++; // �̼߳�����1
- if (initParam->pcName != NULL) {
- ret = (UINT32)OsSetTaskName(taskCB, initParam->pcName, FALSE);
+ SCHEDULER_UNLOCK(intSave); // �����������ж�
+
+ if (initParam->pcName != NULL) { // �������������
+ ret = (UINT32)OsSetTaskName(taskCB, initParam->pcName, FALSE); // ����������
if (ret == LOS_OK) {
return LOS_OK;
}
}
- if (snprintf_s(taskCB->taskName, OS_TCB_NAME_LEN, OS_TCB_NAME_LEN - 1, "thread%u", numCount) < 0) {
+ if (snprintf_s(taskCB->taskName, OS_TCB_NAME_LEN, OS_TCB_NAME_LEN - 1, "thread%u", numCount) < 0) { // ����Ĭ��������
return LOS_NOK;
}
+
return LOS_OK;
}
-LITE_OS_SEC_TEXT LosTaskCB *OsGetFreeTaskCB(VOID)
+LITE_OS_SEC_TEXT LosTaskCB* OsGetFreeTaskCB(VOID)
{
- UINT32 intSave;
- LosTaskCB *taskCB = NULL;
+ UINT32 intSave; // �����ж�״̬�ı���
+ LosTaskCB* taskCB = NULL; // ����������ƿ�ָ��
- SCHEDULER_LOCK(intSave);
- if (LOS_ListEmpty(&g_losFreeTask)) {
- SCHEDULER_UNLOCK(intSave);
- PRINT_ERR("No idle TCB in the system!\n");
+ SCHEDULER_LOCK(intSave); // �رյ������ж�
+
+ if (LOS_ListEmpty(&g_losFreeTask)) { // �����������������
+ SCHEDULER_UNLOCK(intSave); // �����������ж�
+ PRINT_ERR("No idle TCB in the system!\n"); // ��ӡ������Ϣ
#ifdef LOSCFG_DEBUG_VERSION
- (VOID)OsShellCmdTskInfoGet(OS_ALL_TASK_MASK, NULL, OS_PROCESS_INFO_ALL);
+ (VOID)OsShellCmdTskInfoGet(OS_ALL_TASK_MASK, NULL, OS_PROCESS_INFO_ALL); // ���������Ϣ
#endif
return NULL;
- }
+}
- taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_losFreeTask));
- LOS_ListDelete(LOS_DL_LIST_FIRST(&g_losFreeTask));
- SCHEDULER_UNLOCK(intSave);
+ taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&g_losFreeTask)); // �ӿ������������л�ȡһ������������ƿ�
+ LOS_ListDelete(LOS_DL_LIST_FIRST(&g_losFreeTask)); // �ӿ�������������ɾ����������ƿ�
+ SCHEDULER_UNLOCK(intSave); // �����������ж�
- return taskCB;
+ return taskCB; // ���ػ�ȡ�Ŀ���������ƿ�ָ��
}
-LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
+
+LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32* taskID, TSK_INIT_PARAM_S* initParam)
{
- UINT32 intSave, errRet;
- VOID *topStack = NULL;
- VOID *stackPtr = NULL;
- LosTaskCB *taskCB = NULL;
- VOID *pool = NULL;
+ UINT32 intSave, errRet; // �����ж�״̬�ı�������������ֵ
+ VOID* topStack = NULL; // ջ��ָ��
+ VOID* stackPtr = NULL; // ջָ��
+ LosTaskCB* taskCB = NULL; // ������ƿ�ָ��
+ VOID* pool = NULL; // �ڴ��ָ��
- errRet = OsTaskCreateParamCheck(taskID, initParam, &pool);
+ errRet = OsTaskCreateParamCheck(taskID, initParam, &pool); // ������������ĺϷ���
if (errRet != LOS_OK) {
return errRet;
}
- taskCB = OsGetFreeTaskCB();
+ taskCB = OsGetFreeTaskCB(); // ��ȡһ�����е�������ƿ�
if (taskCB == NULL) {
errRet = LOS_ERRNO_TSK_TCB_UNAVAILABLE;
goto LOS_ERREND;
}
- errRet = OsTaskSyncCreate(taskCB);
+ errRet = OsTaskSyncCreate(taskCB); // ��������ͬ������
if (errRet != LOS_OK) {
goto LOS_ERREND_REWIND_TCB;
}
- OsTaskStackAlloc(&topStack, initParam->uwStackSize, pool);
+ OsTaskStackAlloc(&topStack, initParam->uwStackSize, pool); // ��������ջ�ڴ�
if (topStack == NULL) {
errRet = LOS_ERRNO_TSK_NO_MEMORY;
goto LOS_ERREND_REWIND_SYNC;
}
- stackPtr = OsTaskStackInit(taskCB->taskID, initParam->uwStackSize, topStack, TRUE);
- errRet = OsTaskCBInit(taskCB, initParam, stackPtr, topStack);
+ stackPtr = OsTaskStackInit(taskCB->taskID, initParam->uwStackSize, topStack, TRUE); // ��ʼ������ջ
+ errRet = OsTaskCBInit(taskCB, initParam, stackPtr, topStack); // ��ʼ��������ƿ�
if (errRet != LOS_OK) {
goto LOS_ERREND_TCB_INIT;
}
if (OsConsoleIDSetHook != NULL) {
- OsConsoleIDSetHook(taskCB->taskID, OsCurrTaskGet()->taskID);
+ OsConsoleIDSetHook(taskCB->taskID, OsCurrTaskGet()->taskID); // ���ÿ���̨ID�Ĺ��Ӻ���
}
- *taskID = taskCB->taskID;
- OsHookCall(LOS_HOOK_TYPE_TASK_CREATE, taskCB);
+ *taskID = taskCB->taskID; // ��������ID
+ OsHookCall(LOS_HOOK_TYPE_TASK_CREATE, taskCB); // ���������Ĺ��Ӻ���
return LOS_OK;
LOS_ERREND_TCB_INIT:
- (VOID)LOS_MemFree(pool, topStack);
+ (VOID)LOS_MemFree(pool, topStack); // �ͷ�����ջ�ڴ�
LOS_ERREND_REWIND_SYNC:
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
- OsTaskSyncDestroy(taskCB->syncSignal);
+ OsTaskSyncDestroy(taskCB->syncSignal); // ��������ͬ������
#endif
LOS_ERREND_REWIND_TCB:
SCHEDULER_LOCK(intSave);
- OsInsertTCBToFreeList(taskCB);
+ OsInsertTCBToFreeList(taskCB); // ��������ƿ���������������
SCHEDULER_UNLOCK(intSave);
LOS_ERREND:
return errRet;
}
-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 intSave;
- LosTaskCB *taskCB = NULL;
+ UINT32 ret; // ��������ֵ
+ UINT32 intSave; // �����ж�״̬�ı���
+ LosTaskCB* taskCB = NULL; // ������ƿ�ָ��
if (initParam == NULL) {
return LOS_ERRNO_TSK_PTR_NULL;
@@ -682,72 +698,75 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *in
}
if (OsProcessIsUserMode(OsCurrProcessGet())) {
- initParam->processID = OsGetKernelInitProcessID();
- } else {
- initParam->processID = OsCurrProcessGet()->processID;
+ initParam->processID = OsGetKernelInitProcessID(); // �����ǰ�����������û�ģʽ�£�������ID����Ϊ�ں˳�ʼ������ID
+ }
+ else {
+ initParam->processID = OsCurrProcessGet()->processID; // ������ID����Ϊ��ǰ����ID
}
initParam->uwResved &= ~OS_TASK_FLAG_PTHREAD_JOIN;
if (initParam->uwResved & LOS_TASK_STATUS_DETACHED) {
initParam->uwResved = OS_TASK_FLAG_DETACHED;
}
- ret = LOS_TaskCreateOnly(taskID, initParam);
+ ret = LOS_TaskCreateOnly(taskID, initParam); // ������������
if (ret != LOS_OK) {
return ret;
}
- taskCB = OS_TCB_FROM_TID(*taskID);
+ taskCB = OS_TCB_FROM_TID(*taskID); // ��������ID��ȡ������ƿ�ָ��
SCHEDULER_LOCK(intSave);
- OsSchedTaskEnQueue(taskCB);
+ OsSchedTaskEnQueue(taskCB); // �����������ȶ���
SCHEDULER_UNLOCK(intSave);
/* in case created task not running on this core,
schedule or not depends on other schedulers status. */
- LOS_MpSchedule(OS_MP_CPU_ALL);
+ LOS_MpSchedule(OS_MP_CPU_ALL); // �ദ��������
if (OS_SCHEDULER_ACTIVE) {
- LOS_Schedule();
+ LOS_Schedule(); // ��������
}
return LOS_OK;
}
+
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
{
- UINT32 intSave;
- UINT32 errRet;
- LosTaskCB *taskCB = NULL;
- BOOL needSched = FALSE;
+ UINT32 intSave; // �����ж�״̬�ı���
+ UINT32 errRet; // ��������ֵ
+ LosTaskCB* taskCB = NULL; // ������ƿ�ָ��
+ BOOL needSched = FALSE; // �Ƿ���Ҫ����������ȵı�־
if (OS_TID_CHECK_INVALID(taskID)) {
return LOS_ERRNO_TSK_ID_INVALID;
}
- taskCB = OS_TCB_FROM_TID(taskID);
+ taskCB = OS_TCB_FROM_TID(taskID); // ��������ID��ȡ������ƿ�ָ��
SCHEDULER_LOCK(intSave);
- /* clear pending signal */
+ /* ��������ź� */
taskCB->signal &= ~SIGNAL_SUSPEND;
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
errRet = LOS_ERRNO_TSK_NOT_CREATED;
OS_GOTO_ERREND();
- } else if (!(taskCB->taskStatus & OS_TASK_STATUS_SUSPENDED)) {
+ }
+ else if (!(taskCB->taskStatus & OS_TASK_STATUS_SUSPENDED)) {
errRet = LOS_ERRNO_TSK_NOT_SUSPENDED;
OS_GOTO_ERREND();
}
taskCB->taskStatus &= ~OS_TASK_STATUS_SUSPENDED;
if (!(taskCB->taskStatus & OS_CHECK_TASK_BLOCK)) {
- OsSchedTaskEnQueue(taskCB);
+ OsSchedTaskEnQueue(taskCB); // �����������ȶ���
if (OS_SCHEDULER_ACTIVE) {
needSched = TRUE;
}
}
SCHEDULER_UNLOCK(intSave);
- LOS_MpSchedule(OS_MP_CPU_ALL);
+ LOS_MpSchedule(OS_MP_CPU_ALL); // �ദ��������
if (needSched) {
- LOS_Schedule();
+ LOS_Schedule(); // ��������
}
return LOS_OK;
@@ -766,13 +785,13 @@ LOS_ERREND:
* 3. Do the suspension in hard-irq
* then LOS_TaskSuspend will directly return with 'ret' value.
*/
-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 */
+ /* ��ʼ��Ĭ�ϵķ���ֵ */
*ret = LOS_OK;
#ifdef LOSCFG_KERNEL_SMP
- /* ASYNCHRONIZED. No need to do task lock checking */
+ /* �첽���������������������� */
if (taskCB->currCpu != ArchCurrCpuid()) {
taskCB->signal = SIGNAL_SUSPEND;
LOS_MpSchedule(taskCB->currCpu);
@@ -781,13 +800,13 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UIN
#endif
if (!OsPreemptableInSched()) {
- /* Suspending the current core's running task */
+ /* �ڵ����ڼ��ֹ��ռ������ǰ�������������е����� */
*ret = LOS_ERRNO_TSK_SUSPEND_LOCKED;
return FALSE;
}
if (OS_INT_ACTIVE) {
- /* suspend running task in interrupt */
+ /* ����������������� */
taskCB->signal = SIGNAL_SUSPEND;
return FALSE;
}
@@ -795,10 +814,10 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UIN
return TRUE;
}
-LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB *taskCB)
+LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB* taskCB)
{
- UINT32 errRet;
- UINT16 tempStatus;
+ UINT32 errRet; // ��������ֵ
+ UINT16 tempStatus; // ��ʱ�洢����״̬
tempStatus = taskCB->taskStatus;
if (tempStatus & OS_TASK_STATUS_UNUSED) {
@@ -815,55 +834,56 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB *taskCB)
}
if (tempStatus & OS_TASK_STATUS_READY) {
- OsSchedTaskDeQueue(taskCB);
+ OsSchedTaskDeQueue(taskCB); // �ӵ��ȶ������Ƴ�����
}
taskCB->taskStatus |= OS_TASK_STATUS_SUSPENDED;
- OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTOSUSPENDEDLIST, taskCB);
+ OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTOSUSPENDEDLIST, taskCB); // �����������Ĺ��Ӻ���
if (taskCB == OsCurrTaskGet()) {
- OsSchedResched();
+ OsSchedResched(); // ��������
}
return LOS_OK;
}
+
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskID)
{
- UINT32 intSave;
- LosTaskCB *taskCB = NULL;
- UINT32 errRet;
+ UINT32 intSave; // �����ж�״̬�ı���
+ LosTaskCB* taskCB = NULL; // ������ƿ�ָ��
+ UINT32 errRet; // ��������ֵ
if (OS_TID_CHECK_INVALID(taskID)) {
return LOS_ERRNO_TSK_ID_INVALID;
}
- taskCB = OS_TCB_FROM_TID(taskID);
+ taskCB = OS_TCB_FROM_TID(taskID); // ��������ID��ȡ������ƿ�ָ��
if (taskCB->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
return LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
}
SCHEDULER_LOCK(intSave);
- errRet = OsTaskSuspend(taskCB);
+ errRet = OsTaskSuspend(taskCB); // ���ù�������ĺ���
SCHEDULER_UNLOCK(intSave);
return errRet;
}
-STATIC INLINE VOID OsTaskStatusUnusedSet(LosTaskCB *taskCB)
+STATIC INLINE VOID OsTaskStatusUnusedSet(LosTaskCB* taskCB)
{
- taskCB->taskStatus |= OS_TASK_STATUS_UNUSED;
- taskCB->eventMask = 0;
+ taskCB->taskStatus |= OS_TASK_STATUS_UNUSED; // ��������״̬Ϊδʹ��
+ taskCB->eventMask = 0; // ���������¼�����
- OS_MEM_CLEAR(taskCB->taskID);
+ OS_MEM_CLEAR(taskCB->taskID); // �������ID
}
-STATIC INLINE VOID OsTaskReleaseHoldLock(LosProcessCB *processCB, LosTaskCB *taskCB)
+STATIC INLINE VOID OsTaskReleaseHoldLock(LosProcessCB* processCB, LosTaskCB* taskCB)
{
- LosMux *mux = NULL;
- UINT32 ret;
+ LosMux* mux = NULL; // ������ָ��
+ UINT32 ret; // ��������ֵ
while (!LOS_ListEmpty(&taskCB->lockList)) {
mux = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(&taskCB->lockList), LosMux, holdList);
- ret = OsMuxUnlockUnsafe(taskCB, mux, NULL);
+ ret = OsMuxUnlockUnsafe(taskCB, mux, NULL); // ����������еĻ�����
if (ret != LOS_OK) {
LOS_ListDelete(&mux->holdList);
PRINT_ERR("mux ulock failed! : %u\n", ret);
@@ -871,29 +891,31 @@ STATIC INLINE VOID OsTaskReleaseHoldLock(LosProcessCB *processCB, LosTaskCB *tas
}
if (processCB->processMode == OS_USER_MODE) {
- OsTaskJoinPostUnsafe(taskCB);
+ OsTaskJoinPostUnsafe(taskCB); // �û�̬�����˳�ʱ����������
#ifdef LOSCFG_KERNEL_VM
- OsFutexNodeDeleteFromFutexHash(&taskCB->futex, TRUE, NULL, NULL);
+ OsFutexNodeDeleteFromFutexHash(&taskCB->futex, TRUE, NULL, NULL); // ��Futex��ϣ����ɾ�������Futex�ڵ�
#endif
}
- OsTaskSyncWake(taskCB);
+ OsTaskSyncWake(taskCB); // ���ѵȴ������������
+
+ return;
}
-LITE_OS_SEC_TEXT VOID OsRunTaskToDelete(LosTaskCB *runTask)
+LITE_OS_SEC_TEXT VOID OsRunTaskToDelete(LosTaskCB* runTask)
{
- LosProcessCB *processCB = OS_PCB_FROM_PID(runTask->processID);
+ LosProcessCB* processCB = OS_PCB_FROM_PID(runTask->processID); // ��ȡ�����������̵Ľ��̿��ƿ�ָ��
- OsTaskReleaseHoldLock(processCB, runTask);
- OsTaskStatusUnusedSet(runTask);
+ OsTaskReleaseHoldLock(processCB, runTask); // �ͷ�������е�����Դ
+ OsTaskStatusUnusedSet(runTask); // ��������״̬Ϊδʹ��
- LOS_ListDelete(&runTask->threadList);
- processCB->threadNumber--;
- LOS_ListTailInsert(&g_taskRecycleList, &runTask->pendList);
- OsEventWriteUnsafe(&g_resourceEvent, OS_RESOURCE_EVENT_FREE, FALSE, NULL);
+ LOS_ListDelete(&runTask->threadList); // ���߳�������ɾ������
+ processCB->threadNumber--; // ���̵��߳�����һ
+ LOS_ListTailInsert(&g_taskRecycleList, &runTask->pendList); // ��������������������
+ OsEventWriteUnsafe(&g_resourceEvent, OS_RESOURCE_EVENT_FREE, FALSE, NULL); // ������Դ�¼�֪ͨ
- OsSchedResched();
+ OsSchedResched(); // ��������
return;
}
@@ -906,7 +928,8 @@ LITE_OS_SEC_TEXT VOID OsRunTaskToDelete(LosTaskCB *runTask)
* 3. Do the deletion in hard-irq
* then LOS_TaskDelete will directly return with 'ret' value.
*/
-STATIC BOOL OsRunTaskToDeleteCheckOnRun(LosTaskCB *taskCB, UINT32 *ret)
+
+STATIC BOOL OsRunTaskToDeleteCheckOnRun(LosTaskCB* taskCB, UINT32* ret)
{
/* init default out return value */
*ret = LOS_OK;
@@ -915,9 +938,9 @@ STATIC BOOL OsRunTaskToDeleteCheckOnRun(LosTaskCB *taskCB, UINT32 *ret)
/* ASYNCHRONIZED. No need to do task lock checking */
if (taskCB->currCpu != ArchCurrCpuid()) {
/*
- * the task is running on another cpu.
- * mask the target task with "kill" signal, and trigger mp schedule
- * which might not be essential but the deletion could more in time.
+ * ����������һ��CPU�����С�
+ * ʹ��"kill"�ź�����Ŀ�����������ദ�������ȣ�
+ * ����ܲ��DZ���ģ���ɾ�����Ը���ʱ��
*/
taskCB->signal = SIGNAL_KILL;
LOS_MpSchedule(taskCB->currCpu);
@@ -927,15 +950,15 @@ STATIC BOOL OsRunTaskToDeleteCheckOnRun(LosTaskCB *taskCB, UINT32 *ret)
#endif
if (!OsPreemptableInSched()) {
- /* If the task is running and scheduler is locked then you can not delete it */
+ /* ����������������ҵ�����������������ɾ������ */
*ret = LOS_ERRNO_TSK_DELETE_LOCKED;
return FALSE;
}
if (OS_INT_ACTIVE) {
/*
- * delete running task in interrupt.
- * mask "kill" signal and later deletion will be handled.
+ * ���ж���ɾ���������е�����
+ * ����"kill"�źţ��Ժ����ɾ��������
*/
taskCB->signal = SIGNAL_KILL;
return FALSE;
@@ -944,35 +967,35 @@ STATIC BOOL OsRunTaskToDeleteCheckOnRun(LosTaskCB *taskCB, UINT32 *ret)
return TRUE;
}
-STATIC VOID OsTaskDeleteInactive(LosProcessCB *processCB, LosTaskCB *taskCB)
+STATIC VOID OsTaskDeleteInactive(LosProcessCB* processCB, LosTaskCB* taskCB)
{
- LosMux *mux = (LosMux *)taskCB->taskMux;
- UINT16 taskStatus = taskCB->taskStatus;
+ LosMux* mux = (LosMux*)taskCB->taskMux; // ������ָ��
+ UINT16 taskStatus = taskCB->taskStatus; // ����״̬
LOS_ASSERT(!(taskStatus & OS_TASK_STATUS_RUNNING));
- OsTaskReleaseHoldLock(processCB, taskCB);
+ OsTaskReleaseHoldLock(processCB, taskCB); // �ͷ�������е�����Դ
- OsSchedTaskExit(taskCB);
+ OsSchedTaskExit(taskCB); // ���������˳�
if (taskStatus & OS_TASK_STATUS_PENDING) {
if (LOS_MuxIsValid(mux) == TRUE) {
- OsMuxBitmapRestore(mux, taskCB, (LosTaskCB *)mux->owner);
+ OsMuxBitmapRestore(mux, taskCB, (LosTaskCB*)mux->owner);
}
}
- OsTaskStatusUnusedSet(taskCB);
+ OsTaskStatusUnusedSet(taskCB); // ��������״̬Ϊδʹ��
- LOS_ListDelete(&taskCB->threadList);
- processCB->threadNumber--;
- LOS_ListTailInsert(&g_taskRecycleList, &taskCB->pendList);
+ LOS_ListDelete(&taskCB->threadList); // ���߳�������ɾ������
+ processCB->threadNumber--; // ���̵��߳�����һ
+ LOS_ListTailInsert(&g_taskRecycleList, &taskCB->pendList); // ��������������������
return;
}
-LITE_OS_SEC_TEXT UINT32 OsTaskDeleteUnsafe(LosTaskCB *taskCB, UINT32 status, UINT32 intSave)
+LITE_OS_SEC_TEXT UINT32 OsTaskDeleteUnsafe(LosTaskCB* taskCB, UINT32 status, UINT32 intSave)
{
- LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
- UINT32 mode = processCB->processMode;
- UINT32 errRet = LOS_OK;
+ LosProcessCB* processCB = OS_PCB_FROM_PID(taskCB->processID); // ��ȡ�����������̵Ľ��̿��ƿ�ָ��
+ UINT32 mode = processCB->processMode; // ���̵�����ģʽ
+ UINT32 errRet = LOS_OK; // ��������ֵ
if (taskCB->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
errRet = LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
@@ -984,15 +1007,15 @@ LITE_OS_SEC_TEXT UINT32 OsTaskDeleteUnsafe(LosTaskCB *taskCB, UINT32 status, UIN
}
if (!(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
- OsTaskDeleteInactive(processCB, taskCB);
+ OsTaskDeleteInactive(processCB, taskCB); // �������е������ɾ������
SCHEDULER_UNLOCK(intSave);
OsWriteResourceEvent(OS_RESOURCE_EVENT_FREE);
return errRet;
}
- OsHookCall(LOS_HOOK_TYPE_TASK_DELETE, taskCB);
+ OsHookCall(LOS_HOOK_TYPE_TASK_DELETE, taskCB); // ��������ɾ���Ĺ��Ӻ���
if (mode == OS_USER_MODE) {
SCHEDULER_UNLOCK(intSave);
- OsTaskResourcesToFree(taskCB);
+ OsTaskResourcesToFree(taskCB); // �ͷ��������Դ
SCHEDULER_LOCK(intSave);
}
@@ -1001,7 +1024,7 @@ LITE_OS_SEC_TEXT UINT32 OsTaskDeleteUnsafe(LosTaskCB *taskCB, UINT32 status, UIN
#else
LOS_ASSERT(OsPercpuGet()->taskLockCnt == 0);
#endif
- OsRunTaskToDelete(taskCB);
+ OsRunTaskToDelete(taskCB); // �����е������ɾ������
EXIT:
SCHEDULER_UNLOCK(intSave);
@@ -1012,8 +1035,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
{
UINT32 intSave;
UINT32 ret;
- LosTaskCB *taskCB = NULL;
- LosProcessCB *processCB = NULL;
+ LosTaskCB* taskCB = NULL;
+ LosProcessCB* processCB = NULL;
if (OS_TID_CHECK_INVALID(taskID)) {
return LOS_ERRNO_TSK_ID_INVALID;
@@ -1023,7 +1046,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
return LOS_ERRNO_TSK_YIELD_IN_INT;
}
- taskCB = OS_TCB_FROM_TID(taskID);
+ taskCB = OS_TCB_FROM_TID(taskID); // ��ȡ������ƿ�ָ��
SCHEDULER_LOCK(intSave);
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
ret = LOS_ERRNO_TSK_NOT_CREATED;
@@ -1036,11 +1059,11 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
return LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
}
- processCB = OS_PCB_FROM_PID(taskCB->processID);
+ processCB = OS_PCB_FROM_PID(taskCB->processID); // ��ȡ�����������̵Ľ��̿��ƿ�ָ��
if (processCB->threadNumber == 1) { /* 1: The last task of the process exits */
if (processCB == OsCurrProcessGet()) {
SCHEDULER_UNLOCK(intSave);
- OsProcessExit(taskCB, OS_PRO_EXIT_OK);
+ OsProcessExit(taskCB, OS_PRO_EXIT_OK); // �����˳�
return LOS_OK;
}
@@ -1048,7 +1071,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
OS_GOTO_ERREND();
}
- return OsTaskDeleteUnsafe(taskCB, OS_PRO_EXIT_OK, intSave);
+ return OsTaskDeleteUnsafe(taskCB, OS_PRO_EXIT_OK, intSave); // ��������ɾ������
LOS_ERREND:
SCHEDULER_UNLOCK(intSave);
@@ -1058,14 +1081,14 @@ LOS_ERREND:
LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
{
UINT32 intSave;
- LosTaskCB *runTask = NULL;
+ LosTaskCB* runTask = NULL;
if (OS_INT_ACTIVE) {
PRINT_ERR("In interrupt not allow delay task!\n");
return LOS_ERRNO_TSK_DELAY_IN_INT;
}
- runTask = OsCurrTaskGet();
+ runTask = OsCurrTaskGet(); // ��ȡ��ǰ�����������ƿ�ָ��
if (runTask->taskStatus & OS_TASK_FLAG_SYSTEM_TASK) {
OsBackTrace();
return LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
@@ -1074,14 +1097,14 @@ LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
if (!OsPreemptable()) {
return LOS_ERRNO_TSK_DELAY_IN_LOCK;
}
- OsHookCall(LOS_HOOK_TYPE_TASK_DELAY, tick);
+ OsHookCall(LOS_HOOK_TYPE_TASK_DELAY, tick); // ����������ʱ�Ĺ��Ӻ���
if (tick == 0) {
- return LOS_TaskYield();
+ return LOS_TaskYield(); // ���������ó�CPU
}
SCHEDULER_LOCK(intSave);
- OsSchedDelay(runTask, tick);
- OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTODELAYEDLIST, runTask);
+ OsSchedDelay(runTask, tick); // �����������ʱ����
+ OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTODELAYEDLIST, runTask); // ���������ƶ�����ʱ���еĹ��Ӻ���
SCHEDULER_UNLOCK(intSave);
return LOS_OK;
@@ -1090,25 +1113,26 @@ LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskID)
{
UINT32 intSave;
- LosTaskCB *taskCB = NULL;
+ LosTaskCB* taskCB = NULL;
UINT16 priority;
if (OS_TID_CHECK_INVALID(taskID)) {
return (UINT16)OS_INVALID;
}
- taskCB = OS_TCB_FROM_TID(taskID);
+ taskCB = OS_TCB_FROM_TID(taskID); // ��ȡ������ƿ�ָ��
SCHEDULER_LOCK(intSave);
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
SCHEDULER_UNLOCK(intSave);
return (UINT16)OS_INVALID;
}
- priority = taskCB->priority;
+ priority = taskCB->priority; // ��ȡ��������ȼ�
SCHEDULER_UNLOCK(intSave);
return priority;
}
+
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskID, UINT16 taskPrio)
{
UINT32 intSave;