|
|
|
@ -1,6 +1,6 @@
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
|
|
|
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
|
|
|
* Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
|
|
|
|
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
|
|
* are permitted provided that the following conditions are met:
|
|
|
|
* are permitted provided that the following conditions are met:
|
|
|
|
@ -64,11 +64,10 @@
|
|
|
|
#ifdef LOSCFG_KERNEL_CONTAINER
|
|
|
|
#ifdef LOSCFG_KERNEL_CONTAINER
|
|
|
|
#include "los_container_pri.h"
|
|
|
|
#include "los_container_pri.h"
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
#if (LOSCFG_BASE_CORE_TSK_LIMIT <= 0)
|
|
|
|
* @file los_task.c
|
|
|
|
#error "task maxnum cannot be zero"
|
|
|
|
* @brief
|
|
|
|
#endif /* LOSCFG_BASE_CORE_TSK_LIMIT <= 0 */
|
|
|
|
* @verbatim
|
|
|
|
/*
|
|
|
|
|
|
|
|
基本概念
|
|
|
|
基本概念
|
|
|
|
从系统角度看，任务是竞争系统资源的最小运行单元。任务可以使用或等待CPU、
|
|
|
|
从系统角度看，任务是竞争系统资源的最小运行单元。任务可以使用或等待CPU、
|
|
|
|
使用内存空间等系统资源，并独立于其它任务运行。
|
|
|
|
使用内存空间等系统资源，并独立于其它任务运行。
|
|
|
|
@ -138,12 +137,20 @@
|
|
|
|
运作机制
|
|
|
|
运作机制
|
|
|
|
用户创建任务时，系统会初始化任务栈，预置上下文。此外，系统还会将“任务入口函数”
|
|
|
|
用户创建任务时，系统会初始化任务栈，预置上下文。此外，系统还会将“任务入口函数”
|
|
|
|
地址放在相应位置。这样在任务第一次启动进入运行态时，将会执行“任务入口函数”。
|
|
|
|
地址放在相应位置。这样在任务第一次启动进入运行态时，将会执行“任务入口函数”。
|
|
|
|
|
|
|
|
* @endverbatim
|
|
|
|
|
|
|
|
* @param pathname
|
|
|
|
|
|
|
|
* @return int
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if (LOSCFG_BASE_CORE_TSK_LIMIT <= 0)
|
|
|
|
|
|
|
|
#error "task maxnum cannot be zero"
|
|
|
|
|
|
|
|
#endif /* LOSCFG_BASE_CORE_TSK_LIMIT <= 0 */
|
|
|
|
|
|
|
|
|
|
|
|
LITE_OS_SEC_BSS LosTaskCB *g_taskCBArray;//任务池 128个
|
|
|
|
LITE_OS_SEC_BSS LosTaskCB *g_taskCBArray;//任务池 128个
|
|
|
|
LITE_OS_SEC_BSS LOS_DL_LIST g_losFreeTask;//空闲任务链表
|
|
|
|
LITE_OS_SEC_BSS LOS_DL_LIST g_losFreeTask;//空闲任务链表
|
|
|
|
LITE_OS_SEC_BSS LOS_DL_LIST g_taskRecycleList;//回收任务链表
|
|
|
|
LITE_OS_SEC_BSS LOS_DL_LIST g_taskRecycleList;//回收任务链表
|
|
|
|
LITE_OS_SEC_BSS UINT32 g_taskMaxNum;//任务最大个数
|
|
|
|
LITE_OS_SEC_BSS UINT32 g_taskMaxNum;//任务最大个数
|
|
|
|
LITE_OS_SEC_BSS UINT32 g_taskScheduled; /* one bit for each cores */
|
|
|
|
LITE_OS_SEC_BSS UINT32 g_taskScheduled; /* one bit for each cores *///任务调度器,每个CPU都有对应位
|
|
|
|
LITE_OS_SEC_BSS EVENT_CB_S g_resourceEvent;//资源的事件
|
|
|
|
LITE_OS_SEC_BSS EVENT_CB_S g_resourceEvent;//资源的事件
|
|
|
|
/* spinlock for task module, only available on SMP mode */
|
|
|
|
/* spinlock for task module, only available on SMP mode */
|
|
|
|
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_taskSpin);
|
|
|
|
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_taskSpin);
|
|
|
|
@ -178,11 +185,10 @@ VOID OsSetMainTask(VOID)
|
|
|
|
g_mainTask[i].lockDep.waitLock = NULL;
|
|
|
|
g_mainTask[i].lockDep.waitLock = NULL;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
(VOID)strncpy_s(g_mainTask[i].taskName, OS_TCB_NAME_LEN, name, OS_TCB_NAME_LEN - 1);
|
|
|
|
(VOID)strncpy_s(g_mainTask[i].taskName, OS_TCB_NAME_LEN, name, OS_TCB_NAME_LEN - 1);
|
|
|
|
LOS_ListInit(&g_mainTask[i].lockList);//初始化任务锁链表，上面挂的是任务已申请到的互斥锁
|
|
|
|
LOS_ListInit(&g_mainTask[i].lockList);//初始化任务锁链表,上面挂的是任务已申请到的互斥锁
|
|
|
|
(VOID)OsSchedParamInit(&g_mainTask[i], schedParam.policy, &schedParam, NULL);
|
|
|
|
(VOID)OsSchedParamInit(&g_mainTask[i], schedParam.policy, &schedParam, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
VOID OsSetMainTaskProcess(UINTPTR processCB)
|
|
|
|
VOID OsSetMainTaskProcess(UINTPTR processCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
for (UINT32 i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
|
|
|
|
for (UINT32 i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
|
|
|
|
@ -192,11 +198,11 @@ VOID OsSetMainTaskProcess(UINTPTR processCB)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//空闲任务，每个CPU都有自己的空闲任务
|
|
|
|
///空闲任务,每个CPU都有自己的空闲任务
|
|
|
|
LITE_OS_SEC_TEXT WEAK VOID OsIdleTask(VOID)
|
|
|
|
LITE_OS_SEC_TEXT WEAK VOID OsIdleTask(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
while (1) {//只有一个死循环
|
|
|
|
while (1) {//只有一个死循环
|
|
|
|
WFI;//WFI指令：arm core立即进入low-power standly state,进入休眠模式，等待中断
|
|
|
|
WFI;//WFI指令:arm core 立即进入low-power standby state，进入休眠模式，等待中断。
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -204,14 +210,20 @@ VOID OsTaskInsertToRecycleList(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
LOS_ListTailInsert(&g_taskRecycleList, &taskCB->pendList);//将任务挂入回收链表，等待回收
|
|
|
|
LOS_ListTailInsert(&g_taskRecycleList, &taskCB->pendList);//将任务挂入回收链表，等待回收
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
|
|
|
|
查找task通过OS_TCB_FROM_PENDLIST来实现，相当于由LOS_DL_LIST找到LosTaskCB,
|
|
|
|
/*!
|
|
|
|
将这些和参数任务绑在一起的task唤醒
|
|
|
|
* @brief OsTaskJoinPostUnsafe
|
|
|
|
|
|
|
|
* 查找task 通过 OS_TCB_FROM_PENDLIST 来完成,相当于由LOS_DL_LIST找到LosTaskCB,
|
|
|
|
|
|
|
|
* 将那些和参数任务绑在一起的task唤醒.
|
|
|
|
|
|
|
|
* @param taskCB
|
|
|
|
|
|
|
|
* @return
|
|
|
|
|
|
|
|
*
|
|
|
|
|
|
|
|
* @see
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
LITE_OS_SEC_TEXT_INIT VOID OsTaskJoinPostUnsafe(LosTaskCB *taskCB)
|
|
|
|
LITE_OS_SEC_TEXT_INIT VOID OsTaskJoinPostUnsafe(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {//join任务处理
|
|
|
|
if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {//join任务处理
|
|
|
|
if (!LOS_ListEmpty(&taskCB->joinList)) {//joinList中的节点身上都有阻塞标签
|
|
|
|
if (!LOS_ListEmpty(&taskCB->joinList)) {//注意到了这里 joinList中的节点身上都有阻塞标签
|
|
|
|
LosTaskCB *resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(taskCB->joinList)));//通过贴有JOIN标签链表的第一个节点找到Task
|
|
|
|
LosTaskCB *resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(taskCB->joinList)));//通过贴有JOIN标签链表的第一个节点找到Task
|
|
|
|
OsTaskWakeClearPendMask(resumedTask);//清除任务的挂起标记
|
|
|
|
OsTaskWakeClearPendMask(resumedTask);//清除任务的挂起标记
|
|
|
|
resumedTask->ops->wake(resumedTask);
|
|
|
|
resumedTask->ops->wake(resumedTask);
|
|
|
|
@ -219,7 +231,7 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskJoinPostUnsafe(LosTaskCB *taskCB)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
taskCB->taskStatus |= OS_TASK_STATUS_EXIT;//贴上任务退出标签
|
|
|
|
taskCB->taskStatus |= OS_TASK_STATUS_EXIT;//贴上任务退出标签
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//挂起任务，任务进入等待链表，Join代表是支持通过的第一个任务去唤醒其他的任务
|
|
|
|
/// 挂起任务,任务进入等待链表,Join代表是支持通过一个任务去唤醒其他的任务
|
|
|
|
LITE_OS_SEC_TEXT UINT32 OsTaskJoinPendUnsafe(LosTaskCB *taskCB)
|
|
|
|
LITE_OS_SEC_TEXT UINT32 OsTaskJoinPendUnsafe(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_INIT) {
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_INIT) {
|
|
|
|
@ -231,14 +243,14 @@ LITE_OS_SEC_TEXT UINT32 OsTaskJoinPendUnsafe(LosTaskCB *taskCB)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if ((taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) && LOS_ListEmpty(&taskCB->joinList)) {
|
|
|
|
if ((taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) && LOS_ListEmpty(&taskCB->joinList)) {
|
|
|
|
OsTaskWaitSetPendMask(OS_TASK_WAIT_JOIN, taskCB->taskID, LOS_WAIT_FOREVER);
|
|
|
|
OsTaskWaitSetPendMask(OS_TASK_WAIT_JOIN, taskCB->taskID, LOS_WAIT_FOREVER);//设置任务的等待标记
|
|
|
|
LosTaskCB *runTask = OsCurrTaskGet();
|
|
|
|
LosTaskCB *runTask = OsCurrTaskGet();
|
|
|
|
return runTask->ops->wait(runTask, &taskCB->joinList, LOS_WAIT_FOREVER);
|
|
|
|
return runTask->ops->wait(runTask, &taskCB->joinList, LOS_WAIT_FOREVER);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return LOS_EINVAL;
|
|
|
|
return LOS_EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//任务设置分离模式Deatch和JOIN是一对有你没我的状态
|
|
|
|
///任务设置分离模式 Deatch和JOIN是一对有你没我的状态
|
|
|
|
LITE_OS_SEC_TEXT UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB)
|
|
|
|
LITE_OS_SEC_TEXT UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {//join状态时
|
|
|
|
if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {//join状态时
|
|
|
|
@ -261,13 +273,13 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(UINTPTR processCB)
|
|
|
|
UINT32 size;
|
|
|
|
UINT32 size;
|
|
|
|
UINT32 ret;
|
|
|
|
UINT32 ret;
|
|
|
|
|
|
|
|
|
|
|
|
g_taskMaxNum = LOSCFG_BASE_CORE_TSK_LIMIT;//任务池中最多默认128个，可谓铁打的任务池流水的线程
|
|
|
|
g_taskMaxNum = LOSCFG_BASE_CORE_TSK_LIMIT;//任务池中最多默认128个,可谓铁打的任务池流水的线程
|
|
|
|
size = (g_taskMaxNum + 1) * sizeof(LosTaskCB);//计算需分配内存总大小
|
|
|
|
size = (g_taskMaxNum + 1) * sizeof(LosTaskCB);//计算需分配内存总大小
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* This memory is resident memory and is used to save the system resources
|
|
|
|
* This memory is resident memory and is used to save the system resources
|
|
|
|
* of task control block and will not be freed.
|
|
|
|
* 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) {
|
|
|
|
if (g_taskCBArray == NULL) {
|
|
|
|
ret = LOS_ERRNO_TSK_NO_MEMORY;
|
|
|
|
ret = LOS_ERRNO_TSK_NO_MEMORY;
|
|
|
|
goto EXIT;
|
|
|
|
goto EXIT;
|
|
|
|
@ -277,12 +289,11 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(UINTPTR processCB)
|
|
|
|
LOS_ListInit(&g_losFreeTask);//初始化空闲任务链表
|
|
|
|
LOS_ListInit(&g_losFreeTask);//初始化空闲任务链表
|
|
|
|
LOS_ListInit(&g_taskRecycleList);//初始化回收任务链表
|
|
|
|
LOS_ListInit(&g_taskRecycleList);//初始化回收任务链表
|
|
|
|
for (index = 0; index < g_taskMaxNum; index++) {//任务挨个初始化
|
|
|
|
for (index = 0; index < g_taskMaxNum; index++) {//任务挨个初始化
|
|
|
|
g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;//默认未使用，
|
|
|
|
g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;//默认未使用,干净.
|
|
|
|
g_taskCBArray[index].taskID = index;//任务ID [0 ~ g_taskMaxNum - 1]
|
|
|
|
g_taskCBArray[index].taskID = index;//任务ID [0 ~ g_taskMaxNum - 1]
|
|
|
|
g_taskCBArray[index].processCB = processCB;
|
|
|
|
g_taskCBArray[index].processCB = processCB;
|
|
|
|
LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList);//通过pendlist节点插入空闲任务列表
|
|
|
|
LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList);//通过pendList节点插入空闲任务列表
|
|
|
|
}//注意：这里挂的是pendList节点，可以取TCB也要通过OS_TCB_FROM-PENDLIST取
|
|
|
|
}//注意:这里挂的是pendList节点,所以取TCB也要通过 OS_TCB_FROM_PENDLIST 取.
|
|
|
|
|
|
|
|
|
|
|
|
g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;
|
|
|
|
g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;
|
|
|
|
g_taskCBArray[index].taskID = index;
|
|
|
|
g_taskCBArray[index].taskID = index;
|
|
|
|
g_taskCBArray[index].processCB = processCB;
|
|
|
|
g_taskCBArray[index].processCB = processCB;
|
|
|
|
@ -295,34 +306,34 @@ EXIT:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//获取IdletaskId，每个CPU核都对Task进行了内部管理，做到真正的并行处理
|
|
|
|
///获取IdletaskId,每个CPU核都对Task进行了内部管理,做到真正的并行处理
|
|
|
|
UINT32 OsGetIdleTaskId(VOID)
|
|
|
|
UINT32 OsGetIdleTaskId(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
return OsSchedRunqueueIdleGet()->taskID;
|
|
|
|
return OsSchedRunqueueIdleGet()->taskID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//创建一个空闲任务
|
|
|
|
///创建一个空闲任务
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(UINTPTR processID)
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(UINTPTR processID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 ret;
|
|
|
|
UINT32 ret;
|
|
|
|
TSK_INIT_PARAM_S taskInitParam;
|
|
|
|
TSK_INIT_PARAM_S taskInitParam;
|
|
|
|
UINT32 idleTaskID;
|
|
|
|
UINT32 idleTaskID;
|
|
|
|
|
|
|
|
|
|
|
|
(VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));//任务初始参数清零
|
|
|
|
(VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));//任务初始参数清0
|
|
|
|
taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsIdleTask;//入口函数
|
|
|
|
taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsIdleTask;//入口函数
|
|
|
|
taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE;//任务栈大小 2K
|
|
|
|
taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE;//任务栈大小 2K
|
|
|
|
taskInitParam.pcName = "Idle";//任务名称叫pcNAME
|
|
|
|
taskInitParam.pcName = "Idle";//任务名称 叫pcName有点怪怪的,不能换个撒
|
|
|
|
taskInitParam.policy = LOS_SCHED_IDLE;
|
|
|
|
taskInitParam.policy = LOS_SCHED_IDLE;
|
|
|
|
taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;//默认最低优先级 31
|
|
|
|
taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;//默认最低优先级 31
|
|
|
|
taskInitParam.processID = processID;
|
|
|
|
taskInitParam.processID = processID;
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());//每个idle任务只在单独的CPU上运行
|
|
|
|
taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());//每个idle任务只在单独的cpu上运行
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
ret = LOS_TaskCreateOnly(&idleTaskID, &taskInitParam);
|
|
|
|
ret = LOS_TaskCreateOnly(&idleTaskID, &taskInitParam);
|
|
|
|
if (ret != LOS_OK) {
|
|
|
|
if (ret != LOS_OK) {
|
|
|
|
return ret;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
LosTaskCB *idleTask = OS_TCB_FROM_TID(idleTaskID);
|
|
|
|
LosTaskCB *idleTask = OS_TCB_FROM_TID(idleTaskID);
|
|
|
|
idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;//标记为系统任务，idle任务是给CPU休息用的，当然是个系统任务
|
|
|
|
idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK; //标记为系统任务,idle任务是给CPU休息用的,当然是个系统任务
|
|
|
|
OsSchedRunqueueIdleInit(idleTask);
|
|
|
|
OsSchedRunqueueIdleInit(idleTask);
|
|
|
|
|
|
|
|
|
|
|
|
return LOS_TaskResume(idleTaskID);
|
|
|
|
return LOS_TaskResume(idleTaskID);
|
|
|
|
@ -341,7 +352,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return runTask->taskID;
|
|
|
|
return runTask->taskID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//创建指定任务同步信号量
|
|
|
|
/// 创建指定任务同步信号量
|
|
|
|
STATIC INLINE UINT32 TaskSyncCreate(LosTaskCB *taskCB)
|
|
|
|
STATIC INLINE UINT32 TaskSyncCreate(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
@ -354,7 +365,7 @@ STATIC INLINE UINT32 TaskSyncCreate(LosTaskCB *taskCB)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//销毁指定任务同步信号量
|
|
|
|
/// 销毁指定任务同步信号量
|
|
|
|
STATIC INLINE VOID OsTaskSyncDestroy(UINT32 syncSignal)
|
|
|
|
STATIC INLINE VOID OsTaskSyncDestroy(UINT32 syncSignal)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
@ -365,7 +376,14 @@ STATIC INLINE VOID OsTaskSyncDestroy(UINT32 syncSignal)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
//任务同步等待，通过信号量保持同步
|
|
|
|
/*!
|
|
|
|
|
|
|
|
* @brief OsTaskSyncWait
|
|
|
|
|
|
|
|
* 任务同步等待,通过信号量保持同步
|
|
|
|
|
|
|
|
* @param taskCB
|
|
|
|
|
|
|
|
* @return
|
|
|
|
|
|
|
|
*
|
|
|
|
|
|
|
|
* @see
|
|
|
|
|
|
|
|
*/
|
|
|
|
STATIC INLINE UINT32 OsTaskSyncWait(const LosTaskCB *taskCB)
|
|
|
|
STATIC INLINE UINT32 OsTaskSyncWait(const LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
@ -376,9 +394,9 @@ STATIC INLINE UINT32 OsTaskSyncWait(const LosTaskCB *taskCB)
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* gc soft timer works every OS_MP_GC_PERIOD period, to prevent this timer
|
|
|
|
* 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
|
|
|
|
* triggered right at the timeout has reached, we set the timeout as double
|
|
|
|
* of the gc period.
|
|
|
|
* of the gc peroid.
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
if (LOS_SemPend(taskCB->syncSignal, OS_MP_GC_PERIOD * 2) != LOS_OK) { /* 2: Wait 200 ms */
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -391,7 +409,7 @@ STATIC INLINE UINT32 OsTaskSyncWait(const LosTaskCB *taskCB)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
//同步唤醒
|
|
|
|
/// 同步唤醒
|
|
|
|
STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB *taskCB)
|
|
|
|
STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
@ -413,7 +431,7 @@ STATIC INLINE VOID OsInsertTCBToFreeList(LosTaskCB *taskCB)
|
|
|
|
taskCB->taskStatus = OS_TASK_STATUS_UNUSED;
|
|
|
|
taskCB->taskStatus = OS_TASK_STATUS_UNUSED;
|
|
|
|
LOS_ListAdd(&g_losFreeTask, &taskCB->pendList);
|
|
|
|
LOS_ListAdd(&g_losFreeTask, &taskCB->pendList);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//释放任务在内核状态下占用的资源
|
|
|
|
//释放任务在内核态下占用的资源
|
|
|
|
STATIC VOID OsTaskKernelResourcesToFree(UINT32 syncSignal, UINTPTR topOfStack)
|
|
|
|
STATIC VOID OsTaskKernelResourcesToFree(UINT32 syncSignal, UINTPTR topOfStack)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
OsTaskSyncDestroy(syncSignal);//任务销毁，同步信息
|
|
|
|
OsTaskSyncDestroy(syncSignal);//任务销毁，同步信息
|
|
|
|
@ -445,19 +463,19 @@ STATIC VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef LOSCFG_KERNEL_LITEIPC
|
|
|
|
#ifdef LOSCFG_KERNEL_LITEIPC
|
|
|
|
LiteIpcRemoveServiceHandle(taskCB->taskID);
|
|
|
|
LiteIpcRemoveServiceHandle(taskCB->taskID);//详见百篇博客之IPC篇
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {//任务还未使用情况
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {//任务还没有使用情况
|
|
|
|
topOfStack = taskCB->topOfStack;
|
|
|
|
topOfStack = taskCB->topOfStack;
|
|
|
|
taskCB->topOfStack = 0;
|
|
|
|
taskCB->topOfStack = 0;
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
|
|
|
|
syncSignal = taskCB->syncSignal;
|
|
|
|
syncSignal = taskCB->syncSignal;
|
|
|
|
taskCB->syncSignal = LOSCFG_BASE_IPC_SEM_LIMIT;
|
|
|
|
taskCB->syncSignal = LOSCFG_BASE_IPC_SEM_LIMIT;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
OsTaskKernelResourcesToFree(syncSignal, topOfStack);//释放内核所占内存，即内核栈的栈空间
|
|
|
|
OsTaskKernelResourcesToFree(syncSignal, topOfStack);//释放内核态所占内存，即内核态的栈空间
|
|
|
|
|
|
|
|
|
|
|
|
SCHEDULER_LOCK(intSave);
|
|
|
|
SCHEDULER_LOCK(intSave);
|
|
|
|
#ifdef LOSCFG_KERNEL_VM
|
|
|
|
#ifdef LOSCFG_KERNEL_VM
|
|
|
|
@ -489,7 +507,7 @@ LITE_OS_SEC_TEXT VOID OsTaskCBRecycleToFree(void)
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*///所有任务的入口函数，OsTaskEntry是new task OsTaskStackInit时指定的
|
|
|
|
*///所有任务的入口函数,OsTaskEntry是在new task OsTaskStackInit 时指定的
|
|
|
|
LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
|
|
|
|
LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
LOS_ASSERT(!OS_TID_CHECK_INVALID(taskID));
|
|
|
|
LOS_ASSERT(!OS_TID_CHECK_INVALID(taskID));
|
|
|
|
@ -503,7 +521,7 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
|
|
|
|
(VOID)LOS_IntUnLock();//恢复中断
|
|
|
|
(VOID)LOS_IntUnLock();//恢复中断
|
|
|
|
|
|
|
|
|
|
|
|
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
|
|
|
|
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
|
|
|
|
taskCB->joinRetval = taskCB->taskEntry(taskCB->args[0], taskCB->args[1],//调出任务的入口函数
|
|
|
|
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_PTHREAD_JOIN)) {
|
|
|
|
if (!(taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN)) {
|
|
|
|
taskCB->joinRetval = 0;//结合数为0
|
|
|
|
taskCB->joinRetval = 0;//结合数为0
|
|
|
|
@ -511,7 +529,7 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
|
|
|
|
|
|
|
|
|
|
|
|
OsRunningTaskToExit(taskCB, 0);
|
|
|
|
OsRunningTaskToExit(taskCB, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//任务创建参数检查
|
|
|
|
///任务创建参数检查
|
|
|
|
STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
|
|
|
|
STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 poolSize = OS_SYS_MEM_SIZE;
|
|
|
|
UINT32 poolSize = OS_SYS_MEM_SIZE;
|
|
|
|
@ -542,7 +560,7 @@ STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initP
|
|
|
|
return LOS_ERRNO_TSK_STKSZ_TOO_LARGE;
|
|
|
|
return LOS_ERRNO_TSK_STKSZ_TOO_LARGE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (initParam->uwStackSize == 0) {//任何任务都必须由内核态栈，所以uwStackSize不能为0
|
|
|
|
if (initParam->uwStackSize == 0) {//任何任务都必须由内核态栈,所以uwStackSize不能为0
|
|
|
|
initParam->uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
|
|
|
|
initParam->uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
initParam->uwStackSize = (UINT32)ALIGN(initParam->uwStackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
|
|
|
|
initParam->uwStackSize = (UINT32)ALIGN(initParam->uwStackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
|
|
|
|
@ -553,7 +571,7 @@ STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initP
|
|
|
|
|
|
|
|
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//任务栈（内核态）内存分配，由内核态进程空间提供，即KProcess进程空间
|
|
|
|
///任务栈(内核态)内存分配,由内核态进程空间提供,即 KProcess 的进程空间
|
|
|
|
STATIC VOID TaskCBDeInit(LosTaskCB *taskCB)
|
|
|
|
STATIC VOID TaskCBDeInit(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -612,7 +630,7 @@ STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
|
|
|
|
taskCB->futex.index = OS_INVALID_VALUE;
|
|
|
|
taskCB->futex.index = OS_INVALID_VALUE;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//任务初始化
|
|
|
|
///任务初始化
|
|
|
|
STATIC UINT32 TaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
|
|
|
|
STATIC UINT32 TaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 ret;
|
|
|
|
UINT32 ret;
|
|
|
|
@ -621,7 +639,8 @@ STATIC UINT32 TaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
|
|
|
|
LosSchedParam initSchedParam = {0};
|
|
|
|
LosSchedParam initSchedParam = {0};
|
|
|
|
UINT16 policy = (initParam->policy == LOS_SCHED_NORMAL) ? LOS_SCHED_RR : initParam->policy;
|
|
|
|
UINT16 policy = (initParam->policy == LOS_SCHED_NORMAL) ? LOS_SCHED_RR : initParam->policy;
|
|
|
|
|
|
|
|
|
|
|
|
TaskCBBaseInit(taskCB, initParam);//初始化任务的基本信息，task->stackPointer指向内核态栈sp位置，该位置存着任务初始上下文
|
|
|
|
TaskCBBaseInit(taskCB, initParam);//初始化任务的基本信息,
|
|
|
|
|
|
|
|
//taskCB->stackPointer指向内核态栈 sp位置,该位置存着 任务初始上下文
|
|
|
|
|
|
|
|
|
|
|
|
schedParam.policy = policy;
|
|
|
|
schedParam.policy = policy;
|
|
|
|
ret = OsProcessAddNewTask(initParam->processID, taskCB, &schedParam, &numCount);
|
|
|
|
ret = OsProcessAddNewTask(initParam->processID, taskCB, &schedParam, &numCount);
|
|
|
|
@ -673,7 +692,7 @@ STATIC UINT32 TaskStackInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//获取一个空闲TCB
|
|
|
|
///获取一个空闲TCB
|
|
|
|
STATIC LosTaskCB *GetFreeTaskCB(VOID)
|
|
|
|
STATIC LosTaskCB *GetFreeTaskCB(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -691,8 +710,15 @@ STATIC LosTaskCB *GetFreeTaskCB(VOID)
|
|
|
|
|
|
|
|
|
|
|
|
return taskCB;
|
|
|
|
return taskCB;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
|
|
|
|
创建任务，并使该任务进入suspend状态，不对该状态进行调度。如果需要调度，可以调用LOS_TaskResume使该任务进入ready状态
|
|
|
|
/*!
|
|
|
|
|
|
|
|
* @brief LOS_TaskCreateOnly
|
|
|
|
|
|
|
|
* 创建任务，并使该任务进入suspend状态，不对该任务进行调度。如果需要调度，可以调用LOS_TaskResume使该任务进入ready状态
|
|
|
|
|
|
|
|
* @param initParam
|
|
|
|
|
|
|
|
* @param taskID
|
|
|
|
|
|
|
|
* @return
|
|
|
|
|
|
|
|
*
|
|
|
|
|
|
|
|
* @see
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
@ -733,7 +759,7 @@ DEINIT_TCB:
|
|
|
|
TaskCBDeInit(taskCB);
|
|
|
|
TaskCBDeInit(taskCB);
|
|
|
|
return errRet;
|
|
|
|
return errRet;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//创建任务，并使该任务进入ready状态，如果就绪队列中没有更高优先级的任务，则运行该任务
|
|
|
|
///创建任务，并使该任务进入ready状态，如果就绪队列中没有更高优先级的任务，则运行该任务
|
|
|
|
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;
|
|
|
|
@ -773,7 +799,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *in
|
|
|
|
|
|
|
|
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//恢复挂起的任务，是该任务进入ready状态
|
|
|
|
///恢复挂起的任务，使该任务进入ready状态
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -816,7 +842,7 @@ LOS_ERREND:
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* Check if needs to do the suspend operation on the running task. //检查是否需要对正在运行的任务执行挂起操作。
|
|
|
|
* Check if needs to do the suspend operation on the running task. //检查是否需要对正在运行的任务执行挂起操作。
|
|
|
|
* Return TRUE, if needs to do the suspension. //如果需要暂停，返回TRUE。
|
|
|
|
* Return TRUE, if needs to do the suspension. //如果需要暂停，返回TRUE。
|
|
|
|
* Return FALSE, if meets following circumstances: //如果满足一下情况，则返回FALSE：
|
|
|
|
* Rerturn FALSE, if meets following circumstances: //如果满足以下情况，则返回FALSE：
|
|
|
|
* 1. Do the suspension across cores, if SMP is enabled //1.如果启用了SMP，则跨CPU核执行挂起操作
|
|
|
|
* 1. Do the suspension across cores, if SMP is enabled //1.如果启用了SMP，则跨CPU核执行挂起操作
|
|
|
|
* 2. Do the suspension when preemption is disabled //2.当禁用抢占时则挂起
|
|
|
|
* 2. Do the suspension when preemption is disabled //2.当禁用抢占时则挂起
|
|
|
|
* 3. Do the suspension in hard-irq //3.在硬中断时则挂起
|
|
|
|
* 3. Do the suspension in hard-irq //3.在硬中断时则挂起
|
|
|
|
@ -842,7 +868,7 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UIN
|
|
|
|
return FALSE;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (OS_INT_ACTIVE) {//正在硬抢断时
|
|
|
|
if (OS_INT_ACTIVE) {//正在硬中断中
|
|
|
|
/* suspend running task in interrupt */
|
|
|
|
/* suspend running task in interrupt */
|
|
|
|
taskCB->signal = SIGNAL_SUSPEND;
|
|
|
|
taskCB->signal = SIGNAL_SUSPEND;
|
|
|
|
return FALSE;
|
|
|
|
return FALSE;
|
|
|
|
@ -850,7 +876,7 @@ LITE_OS_SEC_TEXT_INIT STATIC BOOL OsTaskSuspendCheckOnRun(LosTaskCB *taskCB, UIN
|
|
|
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//任务暂停，参数可以不是当前任务，也就是说A任务可以让B任务处于阻塞状态，挂起指定的任务，然后切换任务
|
|
|
|
///任务暂停,参数可以不是当前任务，也就是说 A任务可以让B任务处于阻塞状态,挂起指定的任务，然后切换任务
|
|
|
|
LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB *taskCB)
|
|
|
|
LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 errRet;
|
|
|
|
UINT32 errRet;
|
|
|
|
@ -863,14 +889,14 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsTaskSuspend(LosTaskCB *taskCB)
|
|
|
|
return LOS_ERRNO_TSK_ALREADY_SUSPENDED;
|
|
|
|
return LOS_ERRNO_TSK_ALREADY_SUSPENDED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if ((tempStatus & OS_TASK_STATUS_RUNNING) &&//如果参数任务正在运行，注意多Cpu core情况，贴着正在运行标签的任务并不一定是当前CPU的执行任务，
|
|
|
|
if ((tempStatus & OS_TASK_STATUS_RUNNING) && //如果参数任务正在运行，注意多Cpu core情况下，贴着正在运行标签的任务并不一定是当前CPU的执行任务，
|
|
|
|
!OsTaskSuspendCheckOnRun(taskCB, &errRet)) {//很有可能是别的CPU core在跑的任务
|
|
|
|
!OsTaskSuspendCheckOnRun(taskCB, &errRet)) {//很有可能是别的CPU core在跑的任务
|
|
|
|
return errRet;
|
|
|
|
return errRet;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return taskCB->ops->suspend(taskCB);
|
|
|
|
return taskCB->ops->suspend(taskCB);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//外部接口，对OsTaskSuspend的封装
|
|
|
|
///外部接口，对OsTaskSuspend的封装
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskID)
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -890,7 +916,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskID)
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
return errRet;
|
|
|
|
return errRet;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//设置任务为不使用状态
|
|
|
|
///设置任务为不使用状态
|
|
|
|
STATIC INLINE VOID OsTaskStatusUnusedSet(LosTaskCB *taskCB)
|
|
|
|
STATIC INLINE VOID OsTaskStatusUnusedSet(LosTaskCB *taskCB)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
taskCB->taskStatus |= OS_TASK_STATUS_UNUSED;
|
|
|
|
taskCB->taskStatus |= OS_TASK_STATUS_UNUSED;
|
|
|
|
@ -1002,7 +1028,6 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
|
|
|
|
if (!OsPreemptable()) {
|
|
|
|
if (!OsPreemptable()) {
|
|
|
|
return LOS_ERRNO_TSK_DELETE_LOCKED;
|
|
|
|
return LOS_ERRNO_TSK_DELETE_LOCKED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
OsRunningTaskToExit(taskCB, OS_PRO_EXIT_OK);
|
|
|
|
OsRunningTaskToExit(taskCB, OS_PRO_EXIT_OK);
|
|
|
|
return LOS_NOK;
|
|
|
|
return LOS_NOK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1036,7 +1061,7 @@ LOS_ERREND:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//任务延时等待，释放CPU，等待时间到期后该任务会重新进入ready状态
|
|
|
|
///任务延时等待，释放CPU，等待时间到期后该任务会重新进入ready状态
|
|
|
|
LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
|
|
|
|
LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -1066,7 +1091,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_TaskDelay(UINT32 tick)
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
return ret;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//获取任务的优先级
|
|
|
|
///获取任务的优先级
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskID)
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -1078,7 +1103,7 @@ LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskID)
|
|
|
|
|
|
|
|
|
|
|
|
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
|
|
|
|
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
|
|
|
|
SCHEDULER_LOCK(intSave);
|
|
|
|
SCHEDULER_LOCK(intSave);
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {//就这么一句话也要来个自旋锁，内核代码自旋锁真是无处不在啊
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
return (UINT16)OS_INVALID;
|
|
|
|
return (UINT16)OS_INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1087,7 +1112,7 @@ LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskPriGet(UINT32 taskID)
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
return param.priority;
|
|
|
|
return param.priority;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//设置指定任务的优先级
|
|
|
|
///设置指定任务的优先级
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskID, UINT16 taskPrio)
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskID, UINT16 taskPrio)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -1125,12 +1150,13 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskPriSet(UINT32 taskID, UINT16 taskPrio)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//设置当前任务的优先级
|
|
|
|
///设置当前任务的优先级
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//当前任务释放CPU，并将其移到具有相同优先级的就绪任务队列的末尾。
|
|
|
|
|
|
|
|
|
|
|
|
//当前任务释放CPU，并将其移到具有相同优先级的就绪任务队列的末尾. 读懂这个函数 你就彻底搞懂了 yield
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskYield(VOID)
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskYield(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -1176,7 +1202,7 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_TaskUnlock(VOID)
|
|
|
|
LOS_Schedule();
|
|
|
|
LOS_Schedule();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//获取任务信息，给shell使用的
|
|
|
|
//获取任务信息,给shell使用的
|
|
|
|
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;
|
|
|
|
@ -1218,7 +1244,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskID, TSK_INFO_S *taskInf
|
|
|
|
}
|
|
|
|
}
|
|
|
|
taskInfo->acName[LOS_TASK_NAMELEN - 1] = '\0';
|
|
|
|
taskInfo->acName[LOS_TASK_NAMELEN - 1] = '\0';
|
|
|
|
|
|
|
|
|
|
|
|
taskInfo->uwBottomOfStack = TRUNCATE(((UINTPTR)taskCB->topOfStack + taskCB->stackSize),//这里可以看出栈顶地址是高于栈顶
|
|
|
|
taskInfo->uwBottomOfStack = TRUNCATE(((UINTPTR)taskCB->topOfStack + taskCB->stackSize),//这里可以看出栈底地址是高于栈顶
|
|
|
|
OS_TASK_STACK_ADDR_ALIGN);
|
|
|
|
OS_TASK_STACK_ADDR_ALIGN);
|
|
|
|
taskInfo->uwCurrUsed = (UINT32)(taskInfo->uwBottomOfStack - taskInfo->uwSP);//当前任务栈已使用了多少
|
|
|
|
taskInfo->uwCurrUsed = (UINT32)(taskInfo->uwBottomOfStack - taskInfo->uwSP);//当前任务栈已使用了多少
|
|
|
|
|
|
|
|
|
|
|
|
@ -1227,7 +1253,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskInfoGet(UINT32 taskID, TSK_INFO_S *taskInf
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//CPU亲和性（affinity）将任务绑定在指定CPU上，用于多核CPU情况，（该函数仅在SMP模式下支持）
|
|
|
|
///CPU亲和性（affinity）将任务绑在指定CPU上,用于多核CPU情况,（该函数仅在SMP模式下支持）
|
|
|
|
LITE_OS_SEC_TEXT BOOL OsTaskCpuAffiSetUnsafe(UINT32 taskID, UINT16 newCpuAffiMask, UINT16 *oldCpuAffiMask)
|
|
|
|
LITE_OS_SEC_TEXT BOOL OsTaskCpuAffiSetUnsafe(UINT32 taskID, UINT16 newCpuAffiMask, UINT16 *oldCpuAffiMask)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
@ -1253,7 +1279,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuAffiSet(UINT32 taskID, UINT16 cpuAffiMa
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT16 currCpuMask;
|
|
|
|
UINT16 currCpuMask;
|
|
|
|
|
|
|
|
|
|
|
|
if (OS_TID_CHECK_INVALID(taskID)) {//检测taskid是否有效，task由task池分配，鸿蒙默认128个任务 ID范围[0:127]
|
|
|
|
if (OS_TID_CHECK_INVALID(taskID)) {//检测taskid是否有效,task由task池分配,鸿蒙默认128个任务 ID范围[0:127]
|
|
|
|
return LOS_ERRNO_TSK_ID_INVALID;
|
|
|
|
return LOS_ERRNO_TSK_ID_INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -1270,14 +1296,15 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuAffiSet(UINT32 taskID, UINT16 cpuAffiMa
|
|
|
|
needSched = OsTaskCpuAffiSetUnsafe(taskID, cpuAffiMask, &currCpuMask);
|
|
|
|
needSched = OsTaskCpuAffiSetUnsafe(taskID, cpuAffiMask, &currCpuMask);
|
|
|
|
|
|
|
|
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
|
|
|
|
|
|
|
|
if (needSched && OS_SCHEDULER_ACTIVE) {
|
|
|
|
if (needSched && OS_SCHEDULER_ACTIVE) {
|
|
|
|
LOS_MpSchedule(currCpuMask);//发送信号调度信号给目标cpu
|
|
|
|
LOS_MpSchedule(currCpuMask);//发送信号调度信号给目标CPU
|
|
|
|
LOS_Schedule();//申请调度
|
|
|
|
LOS_Schedule();//申请调度
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//查询任务被绑在哪个cpu上
|
|
|
|
///查询任务被绑在哪个CPU上
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskCpuAffiGet(UINT32 taskID)
|
|
|
|
LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskCpuAffiGet(UINT32 taskID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
#ifdef LOSCFG_KERNEL_SMP
|
|
|
|
@ -1302,39 +1329,43 @@ LITE_OS_SEC_TEXT_MINOR UINT16 LOS_TaskCpuAffiGet(UINT32 taskID)
|
|
|
|
return cpuAffiMask;
|
|
|
|
return cpuAffiMask;
|
|
|
|
#else
|
|
|
|
#else
|
|
|
|
(VOID)taskID;
|
|
|
|
(VOID)taskID;
|
|
|
|
return 1;//单核情况直接返回1，0号cpu对应0x01
|
|
|
|
return 1;//单核情况直接返回1 ,0号cpu对应0x01
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* Description : Process pending signals tagged by others cores
|
|
|
|
* Description : Process pending signals tagged by others cores
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
|
|
|
由其他CPU核触发阻塞进程的信号
|
|
|
|
|
|
|
|
函数由汇编代码调用 ..\arch\arm\arm\src\los_dispatch.S
|
|
|
|
|
|
|
|
*/
|
|
|
|
LITE_OS_SEC_TEXT_MINOR VOID OsTaskProcSignal(VOID)
|
|
|
|
LITE_OS_SEC_TEXT_MINOR VOID OsTaskProcSignal(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 ret;
|
|
|
|
UINT32 ret;
|
|
|
|
//私有且不可中断，无需保护。这个任务在其他cpu核看到它时总是在运行，所以它在执行代码的同时也可以继续接收信号
|
|
|
|
//私有且不可中断，无需保护。这个任务在其他CPU核看到它时总是在运行，所以它在执行代码的同时也可以继续接收信号
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* private and uninterruptable, no protection needed.
|
|
|
|
* private and uninterruptable, no protection needed.
|
|
|
|
* while this task is always running when others cores see it,
|
|
|
|
* while this task is always running when others cores see it,
|
|
|
|
* so it keeps receiving signals while follow code executing.
|
|
|
|
* so it keeps receiving signals while follow code executing.
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
LosTaskCB *runTask = OsCurrTaskGet();
|
|
|
|
LosTaskCB *runTask = OsCurrTaskGet();
|
|
|
|
if (runTask->signal == SIGNAL_NONE) {//意思是其他cpu发起了要干掉你的信号
|
|
|
|
if (runTask->signal == SIGNAL_NONE) {
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (runTask->signal & SIGNAL_KILL) {
|
|
|
|
if (runTask->signal & SIGNAL_KILL) {//意思是其他cpu发起了要干掉你的信号
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* clear the signal, and do the task deletion. if the signaled task has been
|
|
|
|
* clear the signal, and do the task deletion. if the signaled task has been
|
|
|
|
* scheduled out, then this deletion will wait until next run.
|
|
|
|
* scheduled out, then this deletion will wait until next run.
|
|
|
|
*///如果发出信号的任务以出调度就绪队列，则此删除将等待下次运行
|
|
|
|
*///如果发出信号的任务已出调度就绪队列，则此删除将等待下次运行
|
|
|
|
runTask->signal = SIGNAL_NONE;//清除信号
|
|
|
|
runTask->signal = SIGNAL_NONE;//清除信号，
|
|
|
|
ret = LOS_TaskDelete(runTask->taskID);
|
|
|
|
ret = LOS_TaskDelete(runTask->taskID);
|
|
|
|
if (ret != LOS_OK) {
|
|
|
|
if (ret != LOS_OK) {
|
|
|
|
PRINT_ERR("Task proc signal delete task(%u) failed err:0x%x\n", runTask->taskID, ret);
|
|
|
|
PRINT_ERR("Task proc signal delete task(%u) failed err:0x%x\n", runTask->taskID, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (runTask->signal & SIGNAL_SUSPEND) {//意思是其他cpu发起了要挂起你的信号
|
|
|
|
} else if (runTask->signal & SIGNAL_SUSPEND) {//意思是其他cpu发起了要挂起你的信号
|
|
|
|
runTask->signal &= ~SIGNAL_SUSPEND;//任务贴在被其他cpu挂起的标签
|
|
|
|
runTask->signal &= ~SIGNAL_SUSPEND;//任务贴上被其他CPU挂起的标签
|
|
|
|
|
|
|
|
|
|
|
|
/* suspend killed task may fail, ignore the result */
|
|
|
|
/* suspend killed task may fail, ignore the result */
|
|
|
|
(VOID)LOS_TaskSuspend(runTask->taskID);
|
|
|
|
(VOID)LOS_TaskSuspend(runTask->taskID);
|
|
|
|
@ -1342,7 +1373,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsTaskProcSignal(VOID)
|
|
|
|
} else if (runTask->signal & SIGNAL_AFFI) {//意思是下次调度其他cpu要媾和你
|
|
|
|
} else if (runTask->signal & SIGNAL_AFFI) {//意思是下次调度其他cpu要媾和你
|
|
|
|
runTask->signal &= ~SIGNAL_AFFI;//任务贴上被其他CPU媾和的标签
|
|
|
|
runTask->signal &= ~SIGNAL_AFFI;//任务贴上被其他CPU媾和的标签
|
|
|
|
|
|
|
|
|
|
|
|
/* priority queue has updated, notify the target cpu */
|
|
|
|
/* pri-queue has updated, notify the target cpu */
|
|
|
|
LOS_MpSchedule((UINT32)runTask->cpuAffiMask);//发生调度,此任务将移交给媾和CPU运行.
|
|
|
|
LOS_MpSchedule((UINT32)runTask->cpuAffiMask);//发生调度,此任务将移交给媾和CPU运行.
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1416,7 +1447,7 @@ INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINTPTR proc
|
|
|
|
|
|
|
|
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//创建任务之前,检查用户态任务栈的参数,是否地址在用户空间
|
|
|
|
///创建任务之前,检查用户态任务栈的参数,是否地址在用户空间
|
|
|
|
LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsCreateUserTaskParamCheck(UINT32 processID, TSK_INIT_PARAM_S *param)
|
|
|
|
LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsCreateUserTaskParamCheck(UINT32 processID, TSK_INIT_PARAM_S *param)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UserTaskParam *userParam = NULL;
|
|
|
|
UserTaskParam *userParam = NULL;
|
|
|
|
@ -1444,7 +1475,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsCreateUserTaskParamCheck(UINT32 processID,
|
|
|
|
|
|
|
|
|
|
|
|
return LOS_OK;
|
|
|
|
return LOS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//创建一个用户态任务
|
|
|
|
///创建一个用户态任务
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_S *initParam)
|
|
|
|
LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_S *initParam)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 taskID;
|
|
|
|
UINT32 taskID;
|
|
|
|
@ -1478,19 +1509,19 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_
|
|
|
|
initParam->periodUs = param.periodUs;
|
|
|
|
initParam->periodUs = param.periodUs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {//进程已经创建
|
|
|
|
} else {//进程已经创建
|
|
|
|
initParam->policy = LOS_SCHED_RR;//调度方式为抢占式，注意鸿蒙不仅仅只支持抢占式调度方式
|
|
|
|
initParam->policy = LOS_SCHED_RR;//调度方式为抢占式,注意鸿蒙不仅仅只支持抢占式调度方式
|
|
|
|
initParam->processID = processID;//进程ID赋值
|
|
|
|
initParam->processID = processID;//进程ID赋值
|
|
|
|
initParam->consoleID = 0;//默认0号控制台
|
|
|
|
initParam->consoleID = 0;//默认0号控制台
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ret = LOS_TaskCreateOnly(&taskID, initParam);//只创建task实体，不申请调度
|
|
|
|
ret = LOS_TaskCreateOnly(&taskID, initParam);//只创建task实体,不申请调度
|
|
|
|
if (ret != LOS_OK) {
|
|
|
|
if (ret != LOS_OK) {
|
|
|
|
return OS_INVALID_VALUE;
|
|
|
|
return OS_INVALID_VALUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return taskID;
|
|
|
|
return taskID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//获取任务的调度方式
|
|
|
|
///获取任务的调度方式
|
|
|
|
LITE_OS_SEC_TEXT INT32 LOS_GetTaskScheduler(INT32 taskID)
|
|
|
|
LITE_OS_SEC_TEXT INT32 LOS_GetTaskScheduler(INT32 taskID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 intSave;
|
|
|
|
UINT32 intSave;
|
|
|
|
@ -1503,7 +1534,7 @@ LITE_OS_SEC_TEXT INT32 LOS_GetTaskScheduler(INT32 taskID)
|
|
|
|
|
|
|
|
|
|
|
|
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
|
|
|
|
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
|
|
|
|
SCHEDULER_LOCK(intSave);
|
|
|
|
SCHEDULER_LOCK(intSave);
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {//任务不能是没有在使用
|
|
|
|
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {//状态不能是没有在使用
|
|
|
|
policy = -LOS_EINVAL;
|
|
|
|
policy = -LOS_EINVAL;
|
|
|
|
OS_GOTO_ERREND();
|
|
|
|
OS_GOTO_ERREND();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1515,6 +1546,7 @@ LOS_ERREND:
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
SCHEDULER_UNLOCK(intSave);
|
|
|
|
return policy;
|
|
|
|
return policy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//设置任务的调度信息
|
|
|
|
//设置任务的调度信息
|
|
|
|
LITE_OS_SEC_TEXT INT32 LOS_SetTaskScheduler(INT32 taskID, UINT16 policy, UINT16 priority)
|
|
|
|
LITE_OS_SEC_TEXT INT32 LOS_SetTaskScheduler(INT32 taskID, UINT16 policy, UINT16 priority)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
@ -1664,7 +1696,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_GetSystemTaskMaximum(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
return g_taskMaxNum;
|
|
|
|
return g_taskMaxNum;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//任务池中最后一个
|
|
|
|
/// 任务池中最后一个
|
|
|
|
LosTaskCB *OsGetDefaultTaskCB(VOID)
|
|
|
|
LosTaskCB *OsGetDefaultTaskCB(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
return &g_taskCBArray[g_taskMaxNum];
|
|
|
|
return &g_taskCBArray[g_taskMaxNum];
|
|
|
|
@ -1679,28 +1711,27 @@ LITE_OS_SEC_TEXT VOID OsWriteResourceEventUnsafe(UINT32 events)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
(VOID)OsEventWriteUnsafe(&g_resourceEvent, events, FALSE, NULL);
|
|
|
|
(VOID)OsEventWriteUnsafe(&g_resourceEvent, events, FALSE, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//资源回收任务
|
|
|
|
///资源回收任务
|
|
|
|
STATIC VOID OsResourceRecoveryTask(VOID)
|
|
|
|
STATIC VOID OsResourceRecoveryTask(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 ret;
|
|
|
|
UINT32 ret;
|
|
|
|
|
|
|
|
|
|
|
|
while (1) {//死循环，回收资源不存在退出情况，只要系统在运行资源就需要回收
|
|
|
|
while (1) {//死循环,回收资源不存在退出情况,只要系统在运行资源就需要回收
|
|
|
|
ret = LOS_EventRead(&g_resourceEvent, OS_RESOURCE_EVENT_MASK,
|
|
|
|
ret = LOS_EventRead(&g_resourceEvent, OS_RESOURCE_EVENT_MASK,
|
|
|
|
LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);//读取资源事件
|
|
|
|
LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);//读取资源事件
|
|
|
|
if (ret & (OS_RESOURCE_EVENT_FREE | OS_RESOURCE_EVENT_OOM)) {//收到资源释放或内存异常情况
|
|
|
|
if (ret & (OS_RESOURCE_EVENT_FREE | OS_RESOURCE_EVENT_OOM)) {//收到资源释放或内存异常情况
|
|
|
|
OsTaskCBRecycleToFree();
|
|
|
|
OsTaskCBRecycleToFree();
|
|
|
|
|
|
|
|
|
|
|
|
OsProcessCBRecycleToFree();//回收进程到空闲进程池
|
|
|
|
OsProcessCBRecycleToFree();//回收进程到空闲进程池
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef LOSCFG_ENABLE_OOM_LOOP_TASK//内存溢出检测任务开关
|
|
|
|
#ifdef LOSCFG_ENABLE_OOM_LOOP_TASK //内存溢出监测任务开关
|
|
|
|
if (ret & OS_RESOURCE_EVENT_OOM) {//触发了这个事件
|
|
|
|
if (ret & OS_RESOURCE_EVENT_OOM) {//触发了这个事件
|
|
|
|
(VOID)OomCheckProcess();//检查进程的内存溢出情况
|
|
|
|
(VOID)OomCheckProcess();//检查进程的内存溢出情况
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//创建一个回收资源的任务
|
|
|
|
///创建一个回收资源的任务
|
|
|
|
LITE_OS_SEC_TEXT UINT32 OsResourceFreeTaskCreate(VOID)
|
|
|
|
LITE_OS_SEC_TEXT UINT32 OsResourceFreeTaskCreate(VOID)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
UINT32 ret;
|
|
|
|
UINT32 ret;
|
|
|
|
@ -1716,7 +1747,7 @@ LITE_OS_SEC_TEXT UINT32 OsResourceFreeTaskCreate(VOID)
|
|
|
|
taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsResourceRecoveryTask;//入口函数
|
|
|
|
taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsResourceRecoveryTask;//入口函数
|
|
|
|
taskInitParam.uwStackSize = OS_TASK_RESOURCE_STATIC_SIZE;
|
|
|
|
taskInitParam.uwStackSize = OS_TASK_RESOURCE_STATIC_SIZE;
|
|
|
|
taskInitParam.pcName = "ResourcesTask";
|
|
|
|
taskInitParam.pcName = "ResourcesTask";
|
|
|
|
taskInitParam.usTaskPrio = OS_TASK_RESOURCE_FREE_PRIORITY;//5，优先级很高
|
|
|
|
taskInitParam.usTaskPrio = OS_TASK_RESOURCE_FREE_PRIORITY;// 5 ,优先级很高
|
|
|
|
ret = LOS_TaskCreate(&taskID, &taskInitParam);
|
|
|
|
ret = LOS_TaskCreate(&taskID, &taskInitParam);
|
|
|
|
if (ret == LOS_OK) {
|
|
|
|
if (ret == LOS_OK) {
|
|
|
|
OS_TCB_FROM_TID(taskID)->taskStatus |= OS_TASK_FLAG_NO_DELETE;
|
|
|
|
OS_TCB_FROM_TID(taskID)->taskStatus |= OS_TASK_FLAG_NO_DELETE;
|
|
|
|
@ -1725,4 +1756,3 @@ LITE_OS_SEC_TEXT UINT32 OsResourceFreeTaskCreate(VOID)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
LOS_MODULE_INIT(OsResourceFreeTaskCreate, LOS_INIT_LEVEL_KMOD_TASK);//资源回收任务初始化
|
|
|
|
LOS_MODULE_INIT(OsResourceFreeTaskCreate, LOS_INIT_LEVEL_KMOD_TASK);//资源回收任务初始化
|
|
|
|
|
|
|
|
|
|
|
|
|
