devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

openharmonyos1.1.0 liteos-a内核学习记录（一）_(void)memset_s(g_taskcbarray, size, 0, size);

作者：菜鸟追梦旅行 | 2024-03-13 07:57:12

赞

踩

(void)memset_s(g_taskcbarray, size, 0, size);

 如果有问题，请加QQ群 891339868 进行交流

一、汇编部分

具体路径为：

1、多核处理器：arch/arm/arm/src/startup/reset_vector_mp.S；

2、单核处理器：arm/arm/arm/src/startup/reset_vector_up.S

汇编看的不是特别明白，但是备注写的还是比较清楚的，根据备注的意思主要是做了以下工作：

（1）、reset相关的寄存器，做一些CPU早期的配置

（2）、计算cpu虚拟地址与物理地址的线性映射关系

（3）、配置MMU相关参数

（4）、物理地址与虚拟地址之间映射页表的创建

、、、

最后跳转到C语言main函数

汇编能力有限，有时间了再深入研究

二、C语言部分

具体的路径为：platform/main.c

1、main函数分析：

  1. LITE_OS_SEC_TEXT_INIT INT32 main(VOID)
  2. {
  3.     UINT32 uwRet = LOS_OK;
  4.  
  5.     OsSetMainTask();//配置系统初始化的任务
  6.     OsCurrTaskSet(OsGetMainTask());
  7.  
  8.     /* set smp system counter freq */
  9. #if (LOSCFG_KERNEL_SMP == YES)
  10. #ifndef LOSCFG_TEE_ENABLE
  11.     HalClockFreqWrite(OS_SYS_CLOCK);
  12. #endif
  13. #endif
  14.  
  15.     /* system and chip info */
  16.     OsSystemInfo();//打印系统的相关信息
  17.  
  18.     PRINT_RELEASE("\nmain core booting up...\n");
  19.  
  20.     uwRet = OsMain();
  21.     if (uwRet != LOS_OK) {
  22.         return LOS_NOK;
  23.     }
  24.  
  25. #if (LOSCFG_KERNEL_SMP == YES)
  26.     PRINT_RELEASE("releasing %u secondary cores\n", LOSCFG_KERNEL_SMP_CORE_NUM - 1);
  27.     release_secondary_cores();
  28. #endif
  29.  
  30.     CPU_MAP_SET(0, OsHwIDGet());
  31.  
  32.     OsSchedStart();//系统使能调度器
  33.  
  34.     while (1) {
  35.         __asm volatile("wfi");
  36.     }
  37. }

这一段代码就是liteos-a的main函数代码，其中的每一个代码段，都非常重要，都有各自非常关键的任务，下面一条一条进行分析：
（1）、OsSetMainTask()

根据函数的名称，应该是设置主函数的任务。跟进去看一下去代码：

  1. 备注：
  2. g_mainTask:struct LosTaskCB结构体数组，每一个元素代表一个任务
  3.  
  4. VOID OsSetMainTask()
  5. {
  6.     UINT32 i;
  7.     CHAR *name = "osMain";
  8.  
  9.     for (i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {//遍历cpu所有核心，配置相关参数
  10.         //LOSCFG_KERNEL_CORE_NUM,CPU核心数目    
  11.         g_mainTask[i].taskStatus = OS_TASK_STATUS_UNUSED;//初始化当前任务的状态为unused
  12.         g_mainTask[i].taskID = LOSCFG_BASE_CORE_TSK_LIMIT;//初始化当前任务ID都为128
  13.         g_mainTask[i].priority = OS_TASK_PRIORITY_LOWEST;//初始化当前任务的优先级都为低
  14. #if (LOSCFG_KERNEL_SMP_LOCKDEP == YES)
  15.         g_mainTask[i].lockDep.lockDepth = 0;
  16.         g_mainTask[i].lockDep.waitLock = NULL;
  17. #endif
  18.         (VOID)strncpy_s(g_mainTask[i].taskName, OS_TCB_NAME_LEN, name, OS_TCB_NAME_LEN - 1);
  19.         LOS_ListInit(&g_mainTask[i].lockList);//
  20.     }
  21. }

（2）、OsGetMainTask（）

应该是获取当前cpu绑定的task，代码跟进去看一下：

  1. 备注：代码很短，就是活动当前CPU所运行的任务，返回当前task指针
  2. LosTaskCB *OsGetMainTask()
  3. {
  4.     return (LosTaskCB *)(g_mainTask + ArchCurrCpuid());
  5. }

（3）、OsCurrTaskSet(OsGetMainTask())

名称看不出来，代码跟进去看一下：

  1. //第一级
  2. STATIC INLINE VOID OsCurrTaskSet(LosTaskCB *task)
  3. {
  4.     ArchCurrTaskSet(task);
  5. }
  6. //第二级
  7. STATIC INLINE VOID ArchCurrTaskSet(VOID *val)
  8. {
  9.     ARM_SYSREG_WRITE(TPIDRPRW, (UINT32)(UINTPTR)val);
  10. }
  11. //第三级
  12. #define ARM_SYSREG_WRITE(REG, val)              \
  13. ({                                              \
  14.     __asm__ volatile("mcr " REG :: "r" (val));  \
  15.     ISB;                                        \
  16. })
  17.  
  18. 备注：
  19. TPIDRPRW = CP15_REG(c13, 0, c0, 4)
  20. #define CP15_REG(CRn, Op1, CRm, Op2)    "p15, "#Op1", %0, "#CRn","#CRm","#Op2
  21.     
  22. 这样一级一级追下去，最终通过汇编代码对寄存器赋值

（4）、HalClockFreqWrite(OS_SYS_CLOCK)

从名称上猜测，应该是时钟的设置，代码追进去看一下：

  1. 第一级：
  2. VOID HalClockFreqWrite(UINT32 freq)
  3. {
  4.     WRITE_TIMER_REG32(TIMER_REG_CNTFRQ, freq);
  5. }
  6. 第二级：
  7. #define WRITE_TIMER_REG32(reg, val) ARM_SYSREG_WRITE(reg, val)
  8. 第三级：
  9. #define ARM_SYSREG_WRITE(REG, val)              \
  10. ({                                              \
  11.     __asm__ volatile("mcr " REG :: "r" (val));  \
  12.     ISB;                                        \
  13. })
  14.  
  15. 备注：
  16. 从代码中可以很清楚的看出来，和上面同样的套路，最终调用arm的汇编语言对相关寄存器进行配置

（5）、OsSystemInfo()

从名称上看应该是系统的相关信息，代码追进去看一下：

  1. LITE_OS_SEC_TEXT_INIT VOID OsSystemInfo(VOID)
  2. {
  3. #ifdef LOSCFG_DEBUG_VERSION
  4.     const CHAR *buildType = "debug";
  5. #else
  6.     const CHAR *buildType = "release";
  7. #endif /* LOSCFG_DEBUG_VERSION */
  8.  
  9.     PRINT_RELEASE("\n******************Welcome******************\n\n"
  10.             "Processor   : %s"
  11. #if (LOSCFG_KERNEL_SMP == YES)
  12.             " * %d\n"
  13.             "Run Mode    : SMP\n"
  14. #else
  15.             "\n"
  16.             "Run Mode    : UP\n"
  17. #endif
  18.             "GIC Rev     : %s\n"
  19.             "build time  : %s %s\n"
  20.             "Kernel      : %s %d.%d.%d.%d/%s\n"
  21.             "\n*******************************************\n",
  22.             LOS_CpuInfo(),
  23. #if (LOSCFG_KERNEL_SMP == YES)
  24.             LOSCFG_KERNEL_SMP_CORE_NUM,
  25. #endif
  26.             HalIrqVersion(), __DATE__, __TIME__,\
  27.             KERNEL_NAME, KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE, buildType);
  28. }
  29. 备注：
  30. 从代码上看，这个子程序就是一个PRINT_RELEASE宏，打印内核名称，主版本号，次版本号，内核补丁等内容，只是打印，没有操作
  31.

（6）、OsMain()

从名字上看，貌似很重要，代码追进去看一看：

  1. LITE_OS_SEC_TEXT_INIT INT32 OsMain(VOID)
  2. {
  3.     UINT32 ret;
  4.  
  5.     osRegister();//看名称是系统注册，其实内容是获取时钟等基本信息
  6. //展开上面osRegister()这个函数看一下
  7. /******************************************************/
  8.     LITE_OS_SEC_TEXT_INIT VOID osRegister(VOID)
  9.     {
  10.         g_sysClock = OS_SYS_CLOCK;//获取系统时钟
  11.         g_tickPerSecond =  LOSCFG_BASE_CORE_TICK_PER_SECOND;//获取系统每秒钟的tick数目（类似于人的心跳）
  12.  
  13.         return;
  14.     }
  15. /******************************************************/
  16.  
  17. #ifdef LOSCFG_SHELL_DMESG
  18.     ret = OsDmesgInit();//Dmesg工具的初始化
  19.     if (ret != LOS_OK) {
  20.         return ret;
  21.     }
  22. //展开上面OsDmesgInit()这个函数看一下
  23. /******************************************************/
  24. UINT32 OsDmesgInit(VOID)
  25. {
  26.     CHAR* buffer = NULL;
  27.  
  28.     buffer = (CHAR *)malloc(KERNEL_LOG_BUF_SIZE + sizeof(DmesgInfo));
  29.     if (buffer == NULL) {
  30.         return LOS_NOK;
  31.     }
  32.     g_mallocAddr = buffer;
  33.     g_dmesgInfo = (DmesgInfo *)buffer;
  34.     g_dmesgInfo->logHead = 0;
  35.     g_dmesgInfo->logTail = 0;
  36.     g_dmesgInfo->logSize = 0;
  37.     g_dmesgInfo->logBuf = buffer + sizeof(DmesgInfo);
  38.     g_logBufSize = KERNEL_LOG_BUF_SIZE;
  39.  
  40.     return LOS_OK;
  41. }
  42. //从上面的代码中，很容易能看出来，就是为了给dmesg工具分配内存，并初始化
  43. /******************************************************/
  44. #endif
  45.  
  46. #ifdef LOSCFG_SHELL_LK
  47.     OsLkLoggerInit(NULL);
  48. //展开上面OsLkLoggerInit(NULL)这个函数看一下
  49. /**************************************************************/
  50.     VOID OsLkLoggerInit(const CHAR *str)
  51.     {
  52.         (VOID)str;
  53.         (VOID)memset_s(&g_logger, sizeof(Logger), 0, sizeof(Logger));//相关内存清零
  54.         OsLkTraceLvSet(TRACE_DEFAULT);//设置内核信息追踪级别
  55.         LOS_LkRegHook(OsLkDefaultFunc);//设置绑定函数
  56.     #ifdef LOSCFG_SHELL_DMESG
  57.         (VOID)LOS_DmesgLvSet(TRACE_DEFAULT);//设置dmesg打印级别
  58.     #endif
  59.     }
  60.    这里面的一个核心结构是Logger,它具体的内容为：
  61.     typedef struct {
  62.         INT32 module_level;
  63.         INT32 trace_level;
  64.         FILE *fp;
  65.     } Logger;
  66.     从这里面可以大概猜出来，就是任务log的级别
  67. /**************************************************************/
  68. #endif
  69.  
  70. #if (LOSCFG_KERNEL_TRACE == YES)
  71.     LOS_TraceInit();
  72. #endif
  73.  
  74. #ifdef LOSCFG_EXC_INTERACTION
  75. #ifdef LOSCFG_ARCH_CORTEX_M7
  76.     /* 4096: 4K space for Stack */
  77.     ret = OsMemExcInteractionInit((UINT32)&__bss_end + 4096);
  78. #else
  79.     ret = OsMemExcInteractionInit((UINTPTR)&__bss_end);
  80. #endif
  81.     if (ret != LOS_OK) {
  82.         return ret;
  83.     }
  84. #endif
  85.  
  86. #if (LOSCFG_PLATFORM_HWI == YES)
  87.     OsHwiInit();//硬件中断初始化
  88. #endif
  89.  
  90.     OsExcInit();//栈初始化
  91.  
  92.     ret = OsTickInit(g_sysClock, LOSCFG_BASE_CORE_TICK_PER_SECOND);//滴答定时初始化
  93.     if (ret != LOS_OK) {
  94.         return ret;
  95.     }
  96.  
  97. #ifdef LOSCFG_PLATFORM_UART_WITHOUT_VFS
  98. #ifdef LOSCFG_DRIVERS
  99.     uart_init();
  100. #endif
  101. #ifdef LOSCFG_SHELL
  102. #endif //LOSCFG_SHELL
  103. #endif //LOSCFG_PLATFORM_UART_WITHOUT_VFS
  104.     ret = OsTaskInit();//系统的任务初始化
  105.     if (ret != LOS_OK) {
  106.         PRINT_ERR("OsTaskInit error\n");
  107.         return ret;
  108.     }
  109. /*上面那个OsTaskInit()函数展开看一下*/
  110. /************************************************/
  111. LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
  112. {
  113.     UINT32 index;
  114.     UINT32 size;
  115.  
  116.     g_taskMaxNum = LOSCFG_BASE_CORE_TSK_LIMIT;//设置系统的同时运行任务最大数
  117.     size = (g_taskMaxNum + 1) * sizeof(LosTaskCB);
  118.     /*
  119.      * This memory is resident memory and is used to save the system resources
  120.      * of task control block and will not be freed.
  121.      */
  122.     g_taskCBArray = (LosTaskCB *)LOS_MemAlloc(m_aucSysMem0, size);//申请空间
  123.     if (g_taskCBArray == NULL) {
  124.         return LOS_ERRNO_TSK_NO_MEMORY;
  125.     }
  126.     (VOID)memset_s(g_taskCBArray, size, 0, size);//空间初始化
  127.  
  128.     LOS_ListInit(&g_losFreeTask);//空闲任务链表初始化
  129.     LOS_ListInit(&g_taskRecyleList);//回收任务链表初始化
  130.     for (index = 0; index < g_taskMaxNum; index++) {//遍历所有任务并初始化
  131.         g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;//设置任务状态
  132.         g_taskCBArray[index].taskID = index;//根据任务在数组的位置设置任务id
  133.         LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList);//将该任务绑定挂起的链表结点加入到空闲任务链表中
  134.     }
  135.  
  136. #if (LOSCFG_KERNEL_TRACE == YES)
  137.     LOS_TraceReg(LOS_TRACE_TASK, OsTaskTrace, LOS_TRACE_TASK_NAME, LOS_TRACE_ENABLE);
  138. #endif
  139.  
  140.     return OsSchedInit();
  141. }
  142. /**************************************************************************/
  143. #if ((LOSCFG_BASE_IPC_QUEUE == YES) || (LOSCFG_BASE_IPC_MUX == YES) || \
  144.      (LOSCFG_BASE_IPC_SEM == YES) || (LOSCFG_BASE_IPC_RWLOCK == YES))
  145.     ret = OsIpcInit();
  146.     if (ret != LOS_OK) {
  147.         return ret;
  148.     }
  149. //展开上面的OsIpcInit()这个函数
  150. LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsIpcInit(VOID)
  151. {
  152.     UINT32 ret;
  153. #if (LOSCFG_BASE_IPC_SEM == YES)
  154.     ret = OsSemInit();//信号量初始化，具体的可以跟进去看一下，其实还是一个套路，按照系统信号量最大的数目限制申请内存，并一一初始化，并将每一个信号量加入到空闲信号量的链表中
  155.     if (ret != LOS_OK) {
  156.         return ret;
  157.     }
  158. #endif
  159.  
  160. #if (LOSCFG_BASE_IPC_QUEUE == YES)
  161.     ret = OsQueueInit();//信号量队列初始化，具体的可以跟进去看一下，和信号量的初始化差不多
  162.     if (ret != LOS_OK) {
  163.         return ret;
  164.     }
  165. #endif
  166.     return LOS_OK;
  167. }
  168.  
  169. #endif
  170.  
  171.     ret = OsSysMemInit();//系统内存初始化，内容还是比较复杂的，包括内存空间的初始化，虚拟内存与物理内存的转换关系，页表的产生，内存映射等内容
  172.     if (ret != LOS_OK) {
  173.         PRINT_ERR("OsSysMemInit error\n");
  174.         return ret;
  175.     }
  176.  
  177.     SyscallHandleInit();
  178.  
  179.     /*
  180.      * CPUP should be inited before first task creation which depends on the semaphore
  181.      * when LOSCFG_KERNEL_SMP_TASK_SYNC is enabled. So don't change this init sequence
  182.      * if not neccessary. The sequence should be like this:
  183.      * 1. OsIpcInit
  184.      * 2. OsCpupInit
  185.      * 3. other inits have task creation
  186.      */
  187. #ifdef LOSCFG_KERNEL_CPUP
  188.     ret = OsCpupInit();
  189.     if (ret != LOS_OK) {
  190.         PRINT_ERR("OsCpupInit error\n");
  191.         return ret;
  192.     }
  193. #endif
  194.  
  195.     ret = OsSystemProcessCreate();//创建系统进程
  196.     if (ret != LOS_OK) {
  197.         return ret;
  198.     }
  199.  
  200. #if (LOSCFG_BASE_CORE_SWTMR == YES)
  201.     ret = OsSwtmrInit();//软件定时器的初始化
  202.     if (ret != LOS_OK) {
  203.         return ret;
  204.     }
  205. #endif
  206.  
  207. #ifdef LOSCFG_KERNEL_CPUP
  208.     OsCpupGuardCreator();//cpu占有率监控进程创建，其实就是定时去采样cpu的状态，里面用到了软件定时器，所以必须在软件定时器初始化以后再创建
  209. #endif
  210.  
  211. #if (LOSCFG_KERNEL_SMP == YES)
  212.     (VOID)OsMpInit();//多核模式下，循环去查询所有的有效任务（线程）的状态，里面也用到了软件定时器
  213. #endif
  214.  
  215. #if defined(LOSCFG_HW_RANDOM_ENABLE) || defined (LOSCFG_DRIVERS_RANDOM)
  216.     random_alg_context.ra_init_alg(NULL);
  217.     run_harvester_iterate(NULL);
  218. #endif
  219.  
  220. #ifdef LOSCFG_COMPAT_BSD
  221.     ret = OsBsdInit();
  222.     if (ret != LOS_OK) {
  223.         PRINT_ERR("init bsd failed!\n");
  224.         return ret;
  225.     }
  226. #endif
  227.  
  228. #ifdef LOSCFG_KERNEL_PIPE
  229.     OsDriverPipeInit();
  230. #endif
  231.  
  232.     ret = OsSystemInit();//系统相关的内容初始化，包括虚拟文件系统，创建SystemInit任务等
  233.     if (ret != LOS_OK) {
  234.         return ret;
  235.     }
  236. #if (LOSCFG_BASE_CORE_HILOG == YES)
  237.     ret = HiLogDriverInit();//看名字是HiLog设备的驱动初始化，可是HiLog是什么设备呢？和海思处理器相关？
  238.     if (ret != LOS_OK) {
  239.         return ret;
  240.     }
  241. #endif
  242.  
  243. #if LOSCFG_DRIVERS_HIEVENT
  244.     OsDriverHiEventInit();
  245. #endif
  246.  
  247. #if (LOSCFG_KERNEL_LITEIPC == YES)
  248.     ret = LiteIpcInit();
  249.     if (ret != LOS_OK) {
  250.         return ret;
  251.     }
  252. #endif
  253.  
  254. #ifdef LOSCFG_KERNEL_VDSO
  255.     ret = OsInitVdso();
  256.     if (ret != LOS_OK) {
  257.         return ret;
  258.     }
  259. #endif
  260.  
  261.     ret = OsFutexInit(); //看名字是fast mutex 初始化，具体功能不详
  262.     if (ret != LOS_OK) {
  263.         PRINT_ERR("Create futex failed : %d!\n", ret);
  264.         return ret;
  265.     }
  266.  
  267.     ret = OomTaskInit(); //看名字是out of memory 任务初始化，具体功能不详
  268.     if (ret != LOS_OK) {
  269.         return ret;
  270.     }
  271.  
  272.     return LOS_OK;
  273. }

（7）、 release_secondary_cores()

从名称上看，应该是启动其他cpu核心，具体代码没有看明白，后期补充

（8）、CPU_MAP_SET(0, OsHwIDGet())

从名称上看，应该是设置cpu核心的ID

（9）、OsSchedStart()

从名称上看，应该是开启系统的各项task，代码跟进去看一下：
 

  1. VOID OsSchedStart(VOID)
  2. {
  3.     UINT32 cpuid = ArchCurrCpuid();//获得当前任务的cpu核心id
  4.     UINT32 intSave;
  5.  
  6.     SCHEDULER_LOCK(intSave);
  7.  
  8.     OsTickStart();//滴答定时器启动
  9.  
  10.     LosTaskCB *newTask = OsGetTopTask();//启动栈顶部的任务
  11.     LosProcessCB *newProcess = OS_PCB_FROM_PID(newTask->processID);//根据当前任务绑定的进程ID创建一个进程
  12.  
  13.     newTask->taskStatus |= OS_TASK_STATUS_RUNNING;//设置任务（线程）的状态
  14.     newProcess->processStatus |= OS_PROCESS_STATUS_RUNNING;//设置进程的状态
  15.     newProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_ADD(newProcess->processStatus);
  16.  
  17.     OsSchedSetStartTime(HalClockGetCycles());
  18.     newTask->startTime = OsGerCurrSchedTimeCycle();
  19.  
  20. #if (LOSCFG_KERNEL_SMP == YES)
  21.     /*
  22.      * attention: current cpu needs to be set, in case first task deletion
  23.      * may fail because this flag mismatch with the real current cpu.
  24.      */
  25.     newTask->currCpu = cpuid;
  26. #endif
  27.  
  28.     OsCurrTaskSet((VOID *)newTask);
  29.  
  30.     /* System start schedule */
  31.     OS_SCHEDULER_SET(cpuid);
  32.  
  33.     OsPercpuGet()->responseID = OS_INVALID;
  34.     OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, newTask->startTime + newTask->timeSlice, OS_INVALID);
  35.  
  36.     PRINTK("cpu %d entering scheduler\n", cpuid);
  37.     OsTaskContextLoad(newTask);
  38. }

到这里，openharmony的liteos-a内核的初始化过程基本上分析完成。好了，今天就记录到这里

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/228508
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号