v05.05 鸿蒙内核源码分析 (任务管理) | 任务池是如何管理的 | 百篇博客分析 HarmonyOS 源码

#define OS_TASK_STATUS_INIT         0x0001U#define OS_TASK_STATUS_READY        0x0002U#define OS_TASK_STATUS_RUNNING      0x0004U#define OS_TASK_STATUS_SUSPEND      0x0008U#define OS_TASK_STATUS_PEND         0x0010U#define OS_TASK_STATUS_DELAY        0x0020U#define OS_TASK_STATUS_TIMEOUT      0x0040U#define OS_TASK_STATUS_PEND_TIME    0x0080U#define OS_TASK_STATUS_EXIT         0x0100U

typedef struct {    VOID            *stackPointer;      /**< Task stack pointer */ //非用户模式下的栈指针    UINT16          taskStatus;         /**< Task status */   //各种状态标签，可以拥有多种标签，按位标识    UINT16          priority;           /**< Task priority */  //任务优先级[0:31]，默认是31级    UINT16          policy;    //任务的调度方式(三种 .. LOS_SCHED_RR )    UINT16          timeSlice;          /**< Remaining time slice *///剩余时间片    UINT32          stackSize;          /**< Task stack size */  //非用户模式下栈大小    UINTPTR         topOfStack;         /**< Task stack top */  //非用户模式下的栈顶 bottom = top + size    UINT32          taskID;             /**< Task ID */    //任务ID，任务池本质是一个大数组，ID就是数组的索引，默认 < 128    TSK_ENTRY_FUNC  taskEntry;          /**< Task entrance function */ //任务执行入口函数    VOID            *joinRetval;        /**< pthread adaption */ //用来存储join线程的返回值    VOID            *taskSem;           /**< Task-held semaphore */ //task在等哪个信号量    VOID            *taskMux;           /**< Task-held mutex */  //task在等哪把锁    VOID            *taskEvent;         /**< Task-held event */  //task在等哪个事件    UINTPTR         args[4];            /**< Parameter， of which the maximum number is 4 */ //入口函数的参数 例如 main (int argc，char *argv[])    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */ //任务的名称    LOS_DL_LIST     pendList;           /**< Task pend node */  //如果任务阻塞时就通过它挂到各种阻塞情况的链表上，比如OsTaskWait时    LOS_DL_LIST     threadList;         /**< thread list */   //挂到所属进程的线程链表上    SortLinkList    sortList;           /**< Task sortlink node */ //挂到cpu core 的任务执行链表上    UINT32          eventMask;          /**< Event mask */   //事件屏蔽    UINT32          eventMode;          /**< Event mode */   //事件模式    UINT32          priBitMap;          /**< BitMap for recording the change of task priority， //任务在执行过程中优先级会经常变化，这个变量用来记录所有曾经变化                                             the priority can not be greater than 31 */   //过的优先级，例如 ..01001011 曾经有过 0，1，3，6 优先级    INT32           errorNo;            /**< Error Num */    UINT32          signal;             /**< Task signal */ //任务信号类型，(SIGNAL_NONE，SIGNAL_KILL，SIGNAL_SUSPEND，SIGNAL_AFFI)    sig_cb          sig;    //信号控制块，这里用于进程间通讯的信号，类似于 linux singal模块#if (LOSCFG_KERNEL_SMP == YES)    UINT16          currCpu;            /**< CPU core number of this task is running on */ //正在运行此任务的CPU内核号    UINT16          lastCpu;            /**< CPU core number of this task is running on last time */ //上次运行此任务的CPU内核号    UINT16          cpuAffiMask;        /**< CPU affinity mask， support up to 16 cores */ //CPU亲和力掩码，最多支持16核，亲和力很重要，多核情况下尽量一个任务在一个CPU核上运行，提高效率    UINT32          timerCpu;           /**< CPU core number of this task is delayed or pended */ //此任务的CPU内核号被延迟或挂起#if (LOSCFG_KERNEL_SMP_TASK_SYNC == YES)    UINT32          syncSignal;         /**< Synchronization for signal handling */ //用于CPU之间 同步信号#endif#if (LOSCFG_KERNEL_SMP_LOCKDEP == YES) //死锁检测开关    LockDep         lockDep;#endif#if (LOSCFG_KERNEL_SCHED_STATISTICS == YES) //调度统计开关，显然打开这个开关性能会受到影响，鸿蒙默认是关闭的    SchedStat       schedStat;          /**< Schedule statistics */ //调度统计#endif#endif    UINTPTR         userArea;   //使用区域，由运行时划定，根据运行态不同而不同    UINTPTR         userMapBase;  //用户模式下的栈底位置    UINT32          userMapSize;        /**< user thread stack size ，real size : userMapSize + USER_STACK_MIN_SIZE */    UINT32          processID;          /**< Which belong process *///所属进程ID    FutexNode       futex;    //实现快锁功能    LOS_DL_LIST     joinList;           /**< join list */ //联结链表，允许任务之间相互释放彼此    LOS_DL_LIST     lockList;           /**< Hold the lock list */ //拿到了哪些锁链表    UINT32          waitID;             /**< Wait for the PID or GID of the child process */ //等待孩子的PID或GID进程    UINT16          waitFlag;           /**< The type of child process that is waiting， belonging to a group or parent，                                             a specific child process， or any child process */#if (LOSCFG_KERNEL_LITEIPC == YES)    UINT32          ipcStatus;   //IPC状态    LOS_DL_LIST     msgListHead;  //消息队列头结点，上面挂的都是任务要读的消息    BOOL            accessMap[LOSCFG_BASE_CORE_TSK_LIMIT];//访问图，指的是task之间是否能访问的标识，LOSCFG_BASE_CORE_TSK_LIMIT 为任务池总数#endif} LosTaskCB;

LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID){    UINT32 index;    UINT32 ret;    UINT32 size;
    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) {        return LOS_ERRNO_TSK_NO_MEMORY;    }    (VOID)memset_s(g_taskCBArray， size， 0， size);
    LOS_ListInit(&g_losFreeTask);//空闲任务链表    LOS_ListInit(&g_taskRecyleList);//需回收任务链表    for (index = 0; index < g_taskMaxNum; index++) {        g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;        g_taskCBArray[index].taskID = index;//任务ID最大默认127        LOS_ListTailInsert(&g_losFreeTask， &g_taskCBArray[index].pendList);//都插入空闲任务列表     }//注意:这里挂的是pendList节点，所以取TCB要通过 OS_TCB_FROM_PENDLIST 取.
    ret = OsPriQueueInit();//创建32个任务优先级队列，即32个双向循环链表    if (ret != LOS_OK) {        return LOS_ERRNO_TSK_NO_MEMORY;    }
    /* init sortlink for each core */    for (index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {        ret = OsSortLinkInit(&g_percpu[index].taskSortLink);//每个CPU内核都有一个执行任务链表        if (ret != LOS_OK) {            return LOS_ERRNO_TSK_NO_MEMORY;        }    }    return LOS_OK;}

#define OS_PRIORITY_QUEUE_NUM 32LITE_OS_SEC_BSS LOS_DL_LIST *g_priQueueList = NULL;//队列链表LITE_OS_SEC_BSS UINT32 g_priQueueBitmap;//队列位图 UINT32每位代表一个优先级，共32个优先级//内部队列初始化UINT32 OsPriQueueInit(VOID){    UINT32 priority;
    /* system resident resource *///常驻内存    g_priQueueList = (LOS_DL_LIST *)LOS_MemAlloc(m_aucSysMem0， (OS_PRIORITY_QUEUE_NUM * sizeof(LOS_DL_LIST)));//分配32个队列头节点    if (g_priQueueList == NULL) {        return LOS_NOK;    }
    for (priority = 0; priority < OS_PRIORITY_QUEUE_NUM; ++priority) {        LOS_ListInit(&g_priQueueList[priority]);//队列初始化，前后指针指向自己    }    return LOS_OK;}

/* The size of this structure must be smaller than or equal to the size specified by OS_TSK_STACK_ALIGN (16 bytes). */typedef struct {   #if !defined(LOSCFG_ARCH_FPU_DISABLE)    UINT64 D[FP_REGS_NUM]; /* D0-D31 */    UINT32 regFPSCR;       /* FPSCR */    UINT32 regFPEXC;       /* FPEXC */#endif    UINT32 resved;          /* It's stack 8 aligned */    UINT32 regPSR;    UINT32 R[GEN_REGS_NUM]; /* R0-R12 */    UINT32 SP;              /* R13 */    UINT32 LR;              /* R14 */    UINT32 PC;              /* R15 */} TaskContext;

LITE_OS_SEC_TEXT_INIT VOID *OsTaskStackInit(UINT32 taskID， UINT32 stackSize， VOID *topStack， BOOL initFlag){       UINT32 index = 1;    TaskContext *taskContext = NULL;
    if (initFlag == TRUE) {           OsStackInit(topStack， stackSize);    }    taskContext = (TaskContext *)(((UINTPTR)topStack + stackSize) - sizeof(TaskContext));//注意看上下文将存放在栈的底部
    /* initialize the task context */#ifdef LOSCFG_GDB    taskContext->PC = (UINTPTR)OsTaskEntrySetupLoopFrame;#else    taskContext->PC = (UINTPTR)OsTaskEntry;//程序计数器，CPU首次执行task时跑的第一条指令位置#endif    taskContext->LR = (UINTPTR)OsTaskExit;  /* LR should be kept， to distinguish it's THUMB or ARM instruction */    taskContext->resved = 0x0;    taskContext->R[0] = taskID;             /* R0 */    taskContext->R[index++] = 0x01010101;   /* R1， 0x01010101 : reg initialed magic word */    for (; index < GEN_REGS_NUM; index++) {   //R2 - R12的初始化很有意思，为什么要这么做？        taskContext->R[index] = taskContext->R[index - 1] + taskContext->R[1]; /* R2 - R12 */    }
#ifdef LOSCFG_INTERWORK_THUMB // 16位模式    taskContext->regPSR = PSR_MODE_SVC_THUMB; /* CPSR (Enable IRQ and FIQ interrupts， THUMNB-mode) */#else    taskContext->regPSR = PSR_MODE_SVC_ARM;   /* CPSR (Enable IRQ and FIQ interrupts， ARM-mode) */#endif
#if !defined(LOSCFG_ARCH_FPU_DISABLE)    /* 0xAAA0000000000000LL : float reg initialed magic word */    for (index = 0; index < FP_REGS_NUM; index++) {           taskContext->D[index] = 0xAAA0000000000000LL + index; /* D0 - D31 */    }    taskContext->regFPSCR = 0;    taskContext->regFPEXC = FP_EN;#endif
    return (VOID *)taskContext;}

接口名 | 描述 LOS_TaskCreateOnly | 创建任务，并使该任务进入suspend状态，并不调度。 LOS_TaskCreate | 创建任务，并使该任务进入ready状态，并调度。 LOS_TaskDelete | 删除指定的任务。 LOS_TaskResume | 恢复挂起的任务。 LOS_TaskSuspend | 挂起指定的任务。 LOS_TaskDelay | 任务延时等待。LOS_TaskYield | 显式放权，调整指定优先级的任务调度顺序。 LOS_TaskLock | 锁任务调度。LOS_TaskUnlock | 解锁任务调度。LOS_CurTaskPriSet | 设置当前任务的优先级。LOS_TaskPriSet | 设置指定任务的优先级。LOS_TaskPriGet | 获取指定任务的优先级。LOS_CurTaskIDGet | 获取当前任务的ID。LOS_TaskInfoGet | 设置指定任务的优先级。LOS_TaskPriGet | 获取指定任务的信息。LOS_TaskStatusGet | 获取指定任务的状态。LOS_TaskNameGet | 获取指定任务的名称。LOS_TaskInfoMonitor | 监控所有任务，获取所有任务的信息。LOS_NextTaskIDGet | 获取即将被调度的任务的ID。

typedef struct tagTskInitParam {//Task的初始化参数    TSK_ENTRY_FUNC  pfnTaskEntry;  /**< Task entrance function */ //任务的入口函数    UINT16          usTaskPrio;    /**< Task priority */ //任务优先级    UINT16          policy;        /**< Task policy */  //任务调度方式    UINTPTR         auwArgs[4];    /**< Task parameters， of which the maximum number is four */ //入口函数的参数，最多四个    UINT32          uwStackSize;   /**< Task stack size */ //任务栈大小    CHAR            *pcName;       /**< Task name */  //任务名称#if (LOSCFG_KERNEL_SMP == YES)    UINT16          usCpuAffiMask; /**< Task cpu affinity mask         */ //任务cpu亲和力掩码#endif    UINT32          uwResved;      /**< It is automatically deleted if set to LOS_TASK_STATUS_DETACHED.                                        It is unable to be deleted if set to 0. */ //如果设置为LOS_TASK_STATUS_DETACHED，则自动删除。如果设置为0，则无法删除    UINT16          consoleID;     /**< The console id of task belongs  */ //任务的控制台id所属    UINT32          processID; //进程ID    UserTaskParam   userParam; //在用户态运行时栈参数} TSK_INIT_PARAM_S;

u32_t osShellPing(int argc， const char **argv){       int ret;    u32_t i = 0;    u32_t count = 0;    int count_set = 0;    u32_t interval = 1000; /* default ping interval */    u32_t data_len = 48; /* default data length */    ip4_addr_t dst_ipaddr;    TSK_INIT_PARAM_S stPingTask;    // ...省去一些中间代码    /* start one task if ping forever or ping count greater than 60 */    if (count == 0 || count > LWIP_SHELL_CMD_PING_RETRY_TIMES) {           if (ping_taskid > 0) {               PRINTK("Ping task already running and only support one now\n");            return LOS_NOK;        }        stPingTask.pfnTaskEntry = (TSK_ENTRY_FUNC)ping_cmd;//线程的执行函数        stPingTask.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;//0x4000 = 16K         stPingTask.pcName = "ping_task";        stPingTask.usTaskPrio = 8; /* higher than shell 优先级高于10，属于内核态线程*/         stPingTask.uwResved = LOS_TASK_STATUS_DETACHED;        stPingTask.auwArgs[0] = dst_ipaddr.addr; /* network order */        stPingTask.auwArgs[1] = count;        stPingTask.auwArgs[2] = interval;        stPingTask.auwArgs[3] = data_len;        ret = LOS_TaskCreate((UINT32 *)(&ping_taskid)， &stPingTask);    } // ...    return LOS_OK;ping_error:    lwip_ping_usage();    return LOS_NOK;}

LITE_OS_SEC_TEXT_MINOR UINT32 ShellTaskInit(ShellCB *shellCB){       CHAR *name = NULL;    TSK_INIT_PARAM_S initParam = {   0};    if (shellCB->consoleID == CONSOLE_SERIAL) {           name = SERIAL_SHELL_TASK_NAME;    } else if (shellCB->consoleID == CONSOLE_TELNET) {           name = TELNET_SHELL_TASK_NAME;    } else {           return LOS_NOK;    }    initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)ShellTask;    initParam.usTaskPrio   = 9; /* 9:shell task priority */    initParam.auwArgs[0]   = (UINTPTR)shellCB;    initParam.uwStackSize  = 0x3000;    initParam.pcName       = name;    initParam.uwResved     = LOS_TASK_STATUS_DETACHED;    (VOID)LOS_EventInit(&shellCB->shellEvent);    return LOS_TaskCreate(&shellCB->shellTaskHandle， &initParam);}

//创建TaskLITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID， TSK_INIT_PARAM_S *initParam){    UINT32 ret;    UINT32 intSave;    LosTaskCB *taskCB = NULL;
    if (initParam == NULL) {        return LOS_ERRNO_TSK_PTR_NULL;    }
    if (OS_INT_ACTIVE) {        return LOS_ERRNO_TSK_YIELD_IN_INT;    }
    if (initParam->uwResved & OS_TASK_FLAG_IDLEFLAG) {//OS_TASK_FLAG_IDLEFLAG 是属于内核 idle进程专用的        initParam->processID = OsGetIdleProcessID();//获取空闲进程    } else if (OsProcessIsUserMode(OsCurrProcessGet())) {//当前进程是否为用户模式        initParam->processID = OsGetKernelInitProcessID();//不是就取"Kernel"进程    } else {        initParam->processID = OsCurrProcessGet()->processID;//获取当前进程 ID赋值    }    initParam->uwResved &= ~OS_TASK_FLAG_IDLEFLAG;//不能是 OS_TASK_FLAG_IDLEFLAG    initParam->uwResved &= ~OS_TASK_FLAG_PTHREAD_JOIN;//不能是 OS_TASK_FLAG_PTHREAD_JOIN    if (initParam->uwResved & LOS_TASK_STATUS_DETACHED) {//是否设置了自动删除        initParam->uwResved = OS_TASK_FLAG_DETACHED;//自动删除，注意这里是 = ，也就是说只有 OS_TASK_FLAG_DETACHED 一个标签了    }
    ret = LOS_TaskCreateOnly(taskID， initParam);//创建一个任务，这是任务创建的实体，前面都只是前期准备工作    if (ret != LOS_OK) {        return ret;    }    taskCB = OS_TCB_FROM_TID(*taskID);//通过ID拿到task实体
    SCHEDULER_LOCK(intSave);    taskCB->taskStatus &= ~OS_TASK_STATUS_INIT;//任务不再是初始化    OS_TASK_SCHED_QUEUE_ENQUEUE(taskCB， 0);//进入调度就绪队列，新任务是直接进入就绪队列的    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);//如果创建的任务没有在这个核心上运行，是否调度取决于其他调度程序的状态。    if (OS_SCHEDULER_ACTIVE) {//当前CPU核处于可调度状态        LOS_Schedule();//发起调度    }
    return LOS_OK;}