los_task_pri.h 文件参考

浏览源代码.

结构体
struct	LosTask
struct	ProcessSignalInfo
struct	OsTaskRobin

类型定义
typedef int(*	ForEachTaskCB) (LosTaskCB *tcb, void *arg)
	回调任务函数,例如:进程被kill 9 时,通知所有任务善后处理 更多...

函数
STATIC INLINE LosTaskCB *	OsGetTaskCB (UINT32 taskID)
	通过任务ID获取任务实体，task由任务池分配，本质是个数组，彼此都挨在一块 更多...
STATIC INLINE BOOL	OsTaskIsUnused (const LosTaskCB *taskCB)
	任务是否在使用 更多...
STATIC INLINE BOOL	OsTaskIsKilled (const LosTaskCB *taskCB)
STATIC INLINE BOOL	OsTaskIsUserMode (const LosTaskCB *taskCB)
STATIC INLINE VOID	OsTaskWaitSetPendMask (UINT16 mask, UINTPTR lockID, UINT32 timeout)
	设置事件阻塞掩码,即设置任务的等待事件. 更多...
STATIC INLINE VOID	OsTaskWakeClearPendMask (LosTaskCB *resumeTask)
	清除事件阻塞掩码,即任务不再等待任何事件. 更多...
UINT32	OsTaskSetDetachUnsafe (LosTaskCB *taskCB)
	任务设置分离模式 Deatch和JOIN是一对有你没我的状态 更多...
VOID	OsTaskJoinPostUnsafe (LosTaskCB *taskCB)
	OsTaskJoinPostUnsafe 查找task 通过 OS_TCB_FROM_PENDLIST 来完成,相当于由LOS_DL_LIST找到LosTaskCB, 将那些和参数任务绑在一起的task唤醒. 更多...
UINT32	OsTaskJoinPendUnsafe (LosTaskCB *taskCB)
	挂起任务,任务进入等待链表,Join代表是支持通过一个任务去唤醒其他的任务 更多...
BOOL	OsTaskCpuAffiSetUnsafe (UINT32 taskID, UINT16 newCpuAffiMask, UINT16 *oldCpuAffiMask)
	CPU亲和性（affinity）将任务绑在指定CPU上,用于多核CPU情况,（该函数仅在SMP模式下支持） 更多...
VOID	OsTaskSchedule (LosTaskCB *, LosTaskCB *)
VOID	OsTaskContextLoad (LosTaskCB *newTask)
VOID	OsIdleTask (VOID)
	空闲任务,每个CPU都有自己的空闲任务 更多...
UINT32	OsIdleTaskCreate (VOID)
	创建一个空闲任务 更多...
UINT32	OsTaskInit (VOID)
UINT32	OsShellCmdDumpTask (INT32 argc, const CHAR **argv)
UINT32	OsShellCmdTskInfoGet (UINT32 taskID, VOID *seqfile, UINT16 flag)
LosTaskCB *	OsGetMainTask (VOID)
VOID	OsSetMainTask (VOID)
UINT32	OsGetIdleTaskId (VOID)
	获取IdletaskId,每个CPU核都对Task进行了内部管理,做到真正的并行处理 更多...
VOID	OsTaskEntry (UINT32 taskID)
VOID	OsTaskProcSignal (VOID)
UINT32	OsCreateUserTask (UINT32 processID, TSK_INIT_PARAM_S *initParam)
	创建一个用户态任务 更多...
INT32	OsSetTaskName (LosTaskCB *taskCB, const CHAR *name, BOOL setPName)
VOID	OsTaskCBRecycleToFree (VOID)
VOID	OsRunningTaskToExit (LosTaskCB *runTask, UINT32 status)
INT32	OsUserTaskOperatePermissionsCheck (const LosTaskCB *taskCB)
INT32	OsUserProcessOperatePermissionsCheck (const LosTaskCB *taskCB, UINT32 processID)
INT32	OsTcbDispatch (LosTaskCB *stcb, siginfo_t *info)
	给任务(线程)发送一个信号 更多...
VOID	OsWriteResourceEvent (UINT32 events)
VOID	OsWriteResourceEventUnsafe (UINT32 events)
UINT32	OsResourceFreeTaskCreate (VOID)
	创建一个回收资源的任务 更多...
VOID	OsTaskInsertToRecycleList (LosTaskCB *taskCB)
VOID	OsInactiveTaskDelete (LosTaskCB *taskCB)

变量
SPIN_LOCK_S	g_taskSpin
UINT32	g_taskMaxNum
	任务最大数量 默认128个 更多...
LosTaskCB *	g_taskCBArray
	外部变量 任务池 默认128个 更多...

类型定义说明

ForEachTaskCB

typedef int(* ForEachTaskCB) (LosTaskCB *tcb, void *arg)

回调任务函数,例如:进程被kill 9 时,通知所有任务善后处理

在文件 los_task_pri.h 第 222 行定义.

函数说明

OsCreateUserTask()

UINT32 OsCreateUserTask	(	UINT32	processID,
		TSK_INIT_PARAM_S *	initParam
	)

创建一个用户态任务

在文件 los_task.c 第 1434 行定义.

{
    UINT32 taskID;
    UINT32 ret;
    UINT32 intSave;
 
    ret = OsCreateUserTaskParamCheck(processID, initParam);//检查参数,堆栈,入口地址必须在用户空间
    if (ret != LOS_OK) {
        return ret;
    }
    //这里可看出一个任务有两个栈,内核态栈(内核指定栈大小)和用户态栈(用户指定栈大小)
    initParam->uwStackSize = OS_USER_TASK_SYSCALL_STACK_SIZE;
    initParam->usTaskPrio = OS_TASK_PRIORITY_LOWEST;//设置最低优先级 31级
    initParam->policy = LOS_SCHED_RR;//调度方式为抢占式,注意鸿蒙不仅仅只支持抢占式调度方式
    if (processID == OS_INVALID_VALUE) {//外面没指定进程ID的处理
        SCHEDULER_LOCK(intSave);
        LosProcessCB *processCB = OsCurrProcessGet();
        initParam->processID = processCB->processID;//进程ID赋值
        initParam->consoleID = processCB->consoleID;//任务控制台ID归属
        SCHEDULER_UNLOCK(intSave);
    } else {//进程已经创建
        initParam->processID = processID;//进程ID赋值
        initParam->consoleID = 0;//默认0号控制台
    }
 
    ret = LOS_TaskCreateOnly(&taskID, initParam);//只创建task实体,不申请调度
    if (ret != LOS_OK) {
        return OS_INVALID_VALUE;
    }
 
    return taskID;
}

函数调用图:

这是这个函数的调用关系图:

OsGetIdleTaskId()

UINT32 OsGetIdleTaskId

(

VOID

)

获取IdletaskId,每个CPU核都对Task进行了内部管理,做到真正的并行处理

在文件 los_task.c 第 295 行定义.

{
    return OsSchedRunqueueIdleGet();
}

函数调用图:

这是这个函数的调用关系图:

OsGetMainTask()

LosTaskCB * OsGetMainTask

(

VOID

)

OsGetTaskCB()

STATIC INLINE LosTaskCB * OsGetTaskCB

(

UINT32

taskID

)

通过任务ID获取任务实体，task由任务池分配，本质是个数组，彼此都挨在一块

在文件 los_task_pri.h 第 250 行定义.

{
    return OS_TCB_FROM_TID(taskID);
}

这是这个函数的调用关系图:

OsIdleTask()

VOID OsIdleTask

(

VOID

)

空闲任务,每个CPU都有自己的空闲任务

在文件 los_task.c 第 191 行定义.

{
    while (1) {//只有一个死循环
        WFI;//WFI指令:arm core 立即进入low-power standby state，进入休眠模式，等待中断。
    }
}

这是这个函数的调用关系图:

OsIdleTaskCreate()

UINT32 OsIdleTaskCreate

(

VOID

)

创建一个空闲任务

在文件 los_task.c 第 300 行定义.

{
    UINT32 ret;
    TSK_INIT_PARAM_S taskInitParam;
    UINT32 idleTaskID;
 
    (VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));//任务初始参数清0
    taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsIdleTask;//入口函数
    taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE;//任务栈大小 2K
    taskInitParam.pcName = "Idle";//任务名称 叫pcName有点怪怪的,不能换个撒
    taskInitParam.policy = LOS_SCHED_IDLE;
    taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;//默认最低优先级 31
    taskInitParam.processID = OsGetIdleProcessID();//任务的进程ID绑定为空闲进程
#ifdef LOSCFG_KERNEL_SMP
    taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());//每个idle任务只在单独的cpu上运行
#endif
    ret = LOS_TaskCreateOnly(&idleTaskID, &taskInitParam);
    if (ret != LOS_OK) {
        return ret;
    }
    LosTaskCB *idleTask = OS_TCB_FROM_TID(idleTaskID);
    idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK; //标记为系统任务,idle任务是给CPU休息用的,当然是个系统任务
    OsSchedRunqueueIdleInit(idleTaskID);
 
    return LOS_TaskResume(idleTaskID);
}

函数调用图:

这是这个函数的调用关系图:

OsInactiveTaskDelete()

VOID OsInactiveTaskDelete

(

LosTaskCB *

taskCB

)

在文件 los_task.c 第 947 行定义.

{
    UINT16 taskStatus = taskCB->taskStatus;
 
    OsTaskReleaseHoldLock(taskCB);
 
    taskCB->ops->exit(taskCB);
    if (taskStatus & OS_TASK_STATUS_PENDING) {
        LosMux *mux = (LosMux *)taskCB->taskMux;
        if (LOS_MuxIsValid(mux) == TRUE) {
            OsMuxBitmapRestore(mux, NULL, taskCB);
        }
    }
 
    OsTaskStatusUnusedSet(taskCB);
 
    OsDeleteTaskFromProcess(taskCB);
 
    OsHookCall(LOS_HOOK_TYPE_TASK_DELETE, taskCB);
}

函数调用图:

这是这个函数的调用关系图:

OsResourceFreeTaskCreate()

UINT32 OsResourceFreeTaskCreate

(

VOID

)

创建一个回收资源的任务

在文件 los_task.c 第 1672 行定义.

{
    UINT32 ret;
    UINT32 taskID;
    TSK_INIT_PARAM_S taskInitParam;
 
    ret = LOS_EventInit((PEVENT_CB_S)&g_resourceEvent);//初始化资源事件
    if (ret != LOS_OK) {
        return LOS_NOK;
    }
 
    (VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
    taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsResourceRecoveryTask;//入口函数
    taskInitParam.uwStackSize = OS_TASK_RESOURCE_STATIC_SIZE;
    taskInitParam.pcName = "ResourcesTask";
    taskInitParam.usTaskPrio = OS_TASK_RESOURCE_FREE_PRIORITY;// 5 ,优先级很高
    ret = LOS_TaskCreate(&taskID, &taskInitParam);
    if (ret == LOS_OK) {
        OS_TCB_FROM_TID(taskID)->taskStatus |= OS_TASK_FLAG_NO_DELETE;
    }
    return ret;
}

函数调用图:

OsRunningTaskToExit()

VOID OsRunningTaskToExit	(	LosTaskCB *	runTask,
		UINT32	status
	)

在文件 los_task.c 第 908 行定义.

{
    UINT32 intSave;
 
    if (OsProcessThreadGroupIDGet(runTask) == runTask->taskID) {
        OsProcessThreadGroupDestroy();
    }
 
    OsHookCall(LOS_HOOK_TYPE_TASK_DELETE, runTask);
 
    SCHEDULER_LOCK(intSave);
    if (OsProcessThreadNumberGet(runTask) == 1) { /* 1: The last task of the process exits */
        SCHEDULER_UNLOCK(intSave);
 
        OsTaskResourcesToFree(runTask);
        OsProcessResourcesToFree(OS_PCB_FROM_PID(runTask->processID));
 
        SCHEDULER_LOCK(intSave);
 
        OsProcessNaturalExit(OS_PCB_FROM_PID(runTask->processID), status);
        OsTaskReleaseHoldLock(runTask);
        OsTaskStatusUnusedSet(runTask);
    } else if (runTask->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
        OsTaskReleaseHoldLock(runTask);
    } else {
        SCHEDULER_UNLOCK(intSave);
 
        OsTaskResourcesToFree(runTask);
 
        SCHEDULER_LOCK(intSave);
        OsInactiveTaskDelete(runTask);
        OsEventWriteUnsafe(&g_resourceEvent, OS_RESOURCE_EVENT_FREE, FALSE, NULL);
    }
 
    OsSchedResched();
    SCHEDULER_UNLOCK(intSave);
    return;
}

函数调用图:

这是这个函数的调用关系图:

OsSetMainTask()

VOID OsSetMainTask

(

VOID

)

OsSetTaskName()

INT32 OsSetTaskName	(	LosTaskCB *	taskCB,
		const CHAR *	name,
		BOOL	setPName
	)

在文件 los_task.c 第 1337 行定义.

{
    UINT32 intSave;
    errno_t err;
    const CHAR *namePtr = NULL;
    CHAR nameBuff[OS_TCB_NAME_LEN] = { 0 };
 
    if ((taskCB == NULL) || (name == NULL)) {
        return EINVAL;
    }
 
    if (LOS_IsUserAddress((VADDR_T)(UINTPTR)name)) {
        err = LOS_StrncpyFromUser(nameBuff, (const CHAR *)name, OS_TCB_NAME_LEN);
        if (err < 0) {
            return -err;
        }
        namePtr = nameBuff;
    } else {
        namePtr = name;
    }
 
    SCHEDULER_LOCK(intSave);
 
    err = strncpy_s(taskCB->taskName, OS_TCB_NAME_LEN, (VOID *)namePtr, OS_TCB_NAME_LEN - 1);
    if (err != EOK) {
        err = EINVAL;
        goto EXIT;
    }
 
    err = LOS_OK;
    /* if thread is main thread, then set processName as taskName */
    if ((taskCB->taskID == OsProcessThreadGroupIDGet(taskCB)) && (setPName == TRUE)) {
        err = (INT32)OsSetProcessName(OS_PCB_FROM_PID(taskCB->processID), (const CHAR *)taskCB->taskName);
        if (err != LOS_OK) {
            err = EINVAL;
        }
    }
 
EXIT:
    SCHEDULER_UNLOCK(intSave);
    return err;
}

函数调用图:

这是这个函数的调用关系图:

OsShellCmdDumpTask()

UINT32 OsShellCmdDumpTask	(	INT32	argc,
		const CHAR **	argv
	)

在文件 task_shellcmd.c 第 615 行定义.

{
    UINT32 flag = 0;
#ifdef LOSCFG_KERNEL_VM
    flag |= OS_PROCESS_MEM_INFO;
#endif
 
    if (argc >= 2) { /* 2: The task shell name restricts the parameters */
        goto TASK_HELP;
    }
 
    if (argc == 1) {
        if (strcmp("-a", argv[0]) == 0) {
            flag |= OS_PROCESS_INFO_ALL;
#ifdef LOSCFG_SCHED_DEBUG
#ifdef LOSCFG_SCHED_TICK_DEBUG
        } else if (strcmp("-i", argv[0]) == 0) {
            if (!OsShellShowTickResponse()) {
                return LOS_OK;
            }
            goto TASK_HELP;
#endif
        } else if (strcmp("-t", argv[0]) == 0) {
            if (!OsShellShowSchedStatistics()) {
                return LOS_OK;
            }
            goto TASK_HELP;
#endif
        } else {
            goto TASK_HELP;
        }
    }
 
    return OsShellCmdTskInfoGet(OS_ALL_TASK_MASK, NULL, flag);
 
TASK_HELP:
    PRINTK("Unknown option: %s\n", argv[0]);
    PRINTK("Usage:\n");
    PRINTK(" task    --- Basic information about all created processes.\n");
    PRINTK(" task -a --- Complete information about all created processes.\n");
    return LOS_NOK;
}

函数调用图:

OsShellCmdTskInfoGet()

UINT32 OsShellCmdTskInfoGet	(	UINT32	taskID,
		VOID *	seqfile,
		UINT16	flag
	)

在文件 task_shellcmd.c 第 585 行定义.

{
    UINT32 size;
    LosProcessCB *pcbArray = NULL;
    LosTaskCB *tcbArray = NULL;
    SchedParam *schedParam = NULL;
    UINTPTR cpupInfo = 0;
 
    if (taskID == OS_ALL_TASK_MASK) {
        if (flag & OS_PROCESS_MEM_INFO) {
            size = OS_PROCESS_ALL_INFO_LEN + OS_PROCESS_MEM_ALL_INFO_LEN + OS_TASK_ALL_INFO_LEN;
        } else {
            size = OS_PROCESS_ALL_INFO_LEN + OS_TASK_ALL_INFO_LEN;
        }
        pcbArray = (LosProcessCB *)LOS_MemAlloc(m_aucSysMem1, size);
        if (pcbArray == NULL) {
            PRINT_ERR("Memory is not enough to save task info!\n");
            return LOS_NOK;
        }
        (VOID)memset_s(pcbArray, size, 0, size);
        ProcessAndTaskInfoGet(&pcbArray, &tcbArray, &schedParam, &cpupInfo, flag);
        ProcessInfoShow(pcbArray, schedParam, cpupInfo, seqBuf, flag);
        TaskInfoData(tcbArray, cpupInfo, seqBuf, flag);
 
        (VOID)LOS_MemFree(m_aucSysMem1, pcbArray);
    }
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsTaskCBRecycleToFree()

VOID OsTaskCBRecycleToFree

(

VOID

)

OsTaskContextLoad()

VOID OsTaskContextLoad

(

LosTaskCB *

newTask

)

这是这个函数的调用关系图:

OsTaskCpuAffiSetUnsafe()

BOOL OsTaskCpuAffiSetUnsafe	(	UINT32	taskID,
		UINT16	newCpuAffiMask,
		UINT16 *	oldCpuAffiMask
	)

CPU亲和性（affinity）将任务绑在指定CPU上,用于多核CPU情况,（该函数仅在SMP模式下支持）

在文件 los_task.c 第 1212 行定义.

{
#ifdef LOSCFG_KERNEL_SMP
    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
 
    taskCB->cpuAffiMask = newCpuAffiMask;
    *oldCpuAffiMask = CPUID_TO_AFFI_MASK(taskCB->currCpu);
    if (!((*oldCpuAffiMask) & newCpuAffiMask)) {
        taskCB->signal = SIGNAL_AFFI;
        return TRUE;
    }
#else
    (VOID)taskID;
    (VOID)newCpuAffiMask;
    (VOID)oldCpuAffiMask;
#endif /* LOSCFG_KERNEL_SMP */
    return FALSE;
}

这是这个函数的调用关系图:

OsTaskEntry()

VOID OsTaskEntry

(

UINT32

taskID

)

在文件 los_task.c 第 493 行定义.

{
    LOS_ASSERT(!OS_TID_CHECK_INVALID(taskID));
 
    /*
     * 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();//恢复中断
 
    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
    taskCB->joinRetval = taskCB->taskEntry(taskCB->args[0], taskCB->args[1],//调用任务的入口函数
                                           taskCB->args[2], taskCB->args[3]); /* 2 & 3: just for args array index */
    if (!(taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN)) {
        taskCB->joinRetval = 0;//结合数为0
    }
    
    OsRunningTaskToExit(taskCB, 0);
}

函数调用图:

这是这个函数的调用关系图:

OsTaskInit()

UINT32 OsTaskInit

(

VOID

)

在文件 los_task.c 第 259 行定义.

{
    UINT32 index;
    UINT32 size;
    UINT32 ret;
 
    g_taskMaxNum = LOSCFG_BASE_CORE_TSK_LIMIT;//任务池中最多默认128个,可谓铁打的任务池流水的线程
    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);//任务池常驻内存,不被释放
    if (g_taskCBArray == NULL) {
        ret = LOS_ERRNO_TSK_NO_MEMORY;
        goto EXIT;
    }
    (VOID)memset_s(g_taskCBArray, size, 0, size);
 
    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;//任务ID [0 ~ g_taskMaxNum - 1]
        LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList);//通过pendList节点插入空闲任务列表 
    }//注意:这里挂的是pendList节点,所以取TCB也要通过 OS_TCB_FROM_PENDLIST 取.
 
    ret = OsSchedInit();//调度器初始化
 
EXIT:
    if (ret != LOS_OK) {
        PRINT_ERR("OsTaskInit error\n");
    }
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsTaskInsertToRecycleList()

VOID OsTaskInsertToRecycleList

(

LosTaskCB *

taskCB

)

在文件 los_task.c 第 198 行定义.

{
    LOS_ListTailInsert(&g_taskRecycleList, &taskCB->pendList);
}

函数调用图:

这是这个函数的调用关系图:

OsTaskIsKilled()

STATIC INLINE BOOL OsTaskIsKilled

(

const LosTaskCB *

taskCB

)

在文件 los_task_pri.h 第 260 行定义.

{
    return ((taskCB->taskStatus & OS_TASK_FLAG_EXIT_KILL) != 0);
}

这是这个函数的调用关系图:

OsTaskIsUnused()

STATIC INLINE BOOL OsTaskIsUnused

(

const LosTaskCB *

taskCB

)

任务是否在使用

在文件 los_task_pri.h 第 255 行定义.

{
    return ((taskCB->taskStatus & OS_TASK_STATUS_UNUSED) != 0);
}

这是这个函数的调用关系图:

OsTaskIsUserMode()

STATIC INLINE BOOL OsTaskIsUserMode

(

const LosTaskCB *

taskCB

)

在文件 los_task_pri.h 第 265 行定义.

{
    return ((taskCB->taskStatus & OS_TASK_FLAG_USER_MODE) != 0);
}

这是这个函数的调用关系图:

OsTaskJoinPendUnsafe()

UINT32 OsTaskJoinPendUnsafe

(

LosTaskCB *

taskCB

)

挂起任务,任务进入等待链表,Join代表是支持通过一个任务去唤醒其他的任务

在文件 los_task.c 第 224 行定义.

{
    if (taskCB->taskStatus & OS_TASK_STATUS_INIT) {
        return LOS_EINVAL;
    }
 
    if (taskCB->taskStatus & OS_TASK_STATUS_EXIT) {
        return LOS_OK;
    }
 
    if ((taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) && LOS_ListEmpty(&taskCB->joinList)) {
        OsTaskWaitSetPendMask(OS_TASK_WAIT_JOIN, taskCB->taskID, LOS_WAIT_FOREVER);//设置任务的等待标记
        LosTaskCB *runTask = OsCurrTaskGet();
        return runTask->ops->wait(runTask, &taskCB->joinList, LOS_WAIT_FOREVER);
    }
 
    return LOS_EINVAL;
}

函数调用图:

这是这个函数的调用关系图:

OsTaskJoinPostUnsafe()

VOID OsTaskJoinPostUnsafe

(

LosTaskCB *

taskCB

)

OsTaskJoinPostUnsafe 查找task 通过 OS_TCB_FROM_PENDLIST 来完成,相当于由LOS_DL_LIST找到LosTaskCB, 将那些和参数任务绑在一起的task唤醒.

参数

taskCB

返回

参见

在文件 los_task.c 第 212 行定义.

{
    if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {//join任务处理
        if (!LOS_ListEmpty(&taskCB->joinList)) {//注意到了这里 joinList中的节点身上都有阻塞标签
            LosTaskCB *resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&(taskCB->joinList)));//通过贴有JOIN标签链表的第一个节点找到Task
            OsTaskWakeClearPendMask(resumedTask);//清除任务的挂起标记
            resumedTask->ops->wake(resumedTask);
        }
    }
    taskCB->taskStatus |= OS_TASK_STATUS_EXIT;//贴上任务退出标签
}

函数调用图:

这是这个函数的调用关系图:

OsTaskProcSignal()

VOID OsTaskProcSignal

(

VOID

)

由其他CPU核触发阻塞进程的信号 函数由汇编代码调用 ..\arch\arm\arm\src\los_dispatch.S

在文件 los_task.c 第 1298 行定义.

{
    UINT32 ret;
    //私有且不可中断，无需保护。这个任务在其他CPU核看到它时总是在运行，所以它在执行代码的同时也可以继续接收信号
    /*
     * private and uninterruptable, no protection needed.
     * while this task is always running when others cores see it,
     * so it keeps receiving signals while follow code executing.
     */
    LosTaskCB *runTask = OsCurrTaskGet();
    if (runTask->signal == SIGNAL_NONE) {
        return;
    }
 
    if (runTask->signal & SIGNAL_KILL) {//意思是其他cpu发起了要干掉你的信号
        /*
         * clear the signal, and do the task deletion. if the signaled task has been
         * scheduled out, then this deletion will wait until next run.
         *///如果发出信号的任务已出调度就绪队列，则此删除将等待下次运行
        runTask->signal = SIGNAL_NONE;//清除信号，
        ret = LOS_TaskDelete(runTask->taskID);
        if (ret != LOS_OK) {
            PRINT_ERR("Task proc signal delete task(%u) failed err:0x%x\n", runTask->taskID, ret);
        }
    } else if (runTask->signal & SIGNAL_SUSPEND) {//意思是其他cpu发起了要挂起你的信号
        runTask->signal &= ~SIGNAL_SUSPEND;//任务贴上被其他CPU挂起的标签
 
        /* suspend killed task may fail, ignore the result */
        (VOID)LOS_TaskSuspend(runTask->taskID);
#ifdef LOSCFG_KERNEL_SMP
    } else if (runTask->signal & SIGNAL_AFFI) {//意思是下次调度其他cpu要媾和你
        runTask->signal &= ~SIGNAL_AFFI;//任务贴上被其他CPU媾和的标签
 
        /* pri-queue has updated, notify the target cpu */
        LOS_MpSchedule((UINT32)runTask->cpuAffiMask);//发生调度,此任务将移交给媾和CPU运行.
#endif
    }
}

函数调用图:

OsTaskSchedule()

VOID OsTaskSchedule	(	LosTaskCB *	,
		LosTaskCB *
	)

这是这个函数的调用关系图:

OsTaskSetDetachUnsafe()

UINT32 OsTaskSetDetachUnsafe

(

LosTaskCB *

taskCB

)

任务设置分离模式 Deatch和JOIN是一对有你没我的状态

在文件 los_task.c 第 243 行定义.

{
    if (taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {//join状态时
        if (LOS_ListEmpty(&(taskCB->joinList))) {//joinlist中没有数据了
            LOS_ListDelete(&(taskCB->joinList));//所谓删除就是自己指向自己
            taskCB->taskStatus &= ~OS_TASK_FLAG_PTHREAD_JOIN;//去掉JOIN标签
            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_EINVAL;
}

函数调用图:

这是这个函数的调用关系图:

OsTaskWaitSetPendMask()

STATIC INLINE VOID OsTaskWaitSetPendMask	(	UINT16	mask,
		UINTPTR	lockID,
		UINT32	timeout
	)

设置事件阻塞掩码,即设置任务的等待事件.

在文件 los_task_pri.h 第 289 行定义.

{
    LosTaskCB *runTask = OsCurrTaskGet();
    runTask->waitID = lockID; //
    runTask->waitFlag = mask; //当前任务在等待什么东东到来 例如: OS_TASK_WAIT_LITEIPC
    (VOID)timeout;
}

函数调用图:

这是这个函数的调用关系图:

OsTaskWakeClearPendMask()

STATIC INLINE VOID OsTaskWakeClearPendMask

(

LosTaskCB *

resumeTask

)

清除事件阻塞掩码,即任务不再等待任何事件.

在文件 los_task_pri.h 第 298 行定义.

{
    resumeTask->waitID = 0;
    resumeTask->waitFlag = 0;
}

这是这个函数的调用关系图:

OsTcbDispatch()

INT32 OsTcbDispatch	(	LosTaskCB *	stcb,
		siginfo_t *	info
	)

给任务(线程)发送一个信号

在文件 los_signal.c 第 182 行定义.

{
    bool masked = FALSE;
    sig_cb *sigcb = &stcb->sig;
 
    OS_RETURN_IF_NULL(sigcb);
    /* If signo is 0, not send signal, just check process or pthread exist */
    if (info->si_signo == 0) {//如果信号为0,则不发送信号,只是作为检查进程和线程是否还存在.
        return 0;
    }
    masked = (bool)OsSigIsMember(&sigcb->sigprocmask, info->si_signo);//@note_thinking 这里还有 masked= -1的情况要处理!!!
    if (masked) {//如果信号被屏蔽了,要看等待信号集,sigwaitmask
        /* If signal is in wait list and mask list, need unblock it */ //如果信号在等待列表和掩码列表中，需要解除阻止
        if (LOS_ListEmpty(&sigcb->waitList)  ||
           (!LOS_ListEmpty(&sigcb->waitList) && !OsSigIsMember(&sigcb->sigwaitmask, info->si_signo))) {
            OsSigAddSet(&sigcb->sigPendFlag, info->si_signo);//将信号加入挂起/待办集
        }
    } else {//信号没有被屏蔽的处理
        /* unmasked signal actions */
        OsSigAddSet(&sigcb->sigFlag, info->si_signo);//不屏蔽的信号集
    }
 
    if (OsAddSigInfoToTmpList(sigcb, info) == LOS_NOK) {
        return -ENOMEM;
    }
 
    return OsPendingTaskWake(stcb, info->si_signo);
}

函数调用图:

这是这个函数的调用关系图:

OsUserProcessOperatePermissionsCheck()

INT32 OsUserProcessOperatePermissionsCheck	(	const LosTaskCB *	taskCB,
		UINT32	processID
	)

在文件 los_task.c 第 1385 行定义.

{
    if (taskCB == NULL) {
        return LOS_EINVAL;
    }
 
    if (processID == OS_INVALID_VALUE) {
        return LOS_EINVAL;
    }
 
    if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
        return LOS_EINVAL;
    }
 
    if (processID != taskCB->processID) {
        return LOS_EPERM;
    }
 
    return LOS_OK;
}

这是这个函数的调用关系图:

OsUserTaskOperatePermissionsCheck()

INT32 OsUserTaskOperatePermissionsCheck

(

const LosTaskCB *

taskCB

)

在文件 los_task.c 第 1380 行定义.

{
    return OsUserProcessOperatePermissionsCheck(taskCB, OsCurrProcessGet()->processID);
}

函数调用图:

这是这个函数的调用关系图:

OsWriteResourceEvent()

VOID OsWriteResourceEvent

(

UINT32

events

)

在文件 los_task.c 第 1642 行定义.

{
    (VOID)LOS_EventWrite(&g_resourceEvent, events);
}

函数调用图:

这是这个函数的调用关系图:

OsWriteResourceEventUnsafe()

VOID OsWriteResourceEventUnsafe

(

UINT32

events

)

在文件 los_task.c 第 1647 行定义.

{
    (VOID)OsEventWriteUnsafe(&g_resourceEvent, events, FALSE, NULL);
}

函数调用图:

变量说明

g_taskSpin

SPIN_LOCK_S g_taskSpin

extern