Zephyr学习（三）启动过程

一.写在前面

最近对zephyr这个系统很感兴趣，因此业余有时间的时候都在研究它的源码，而光看代码不去动手这不是我的风格，于是乎在网上淘了一块STM32F103C8T6的核心板和一块NRF52832的最小系统板。由于zephyr支持很多种开发板，因此一行代码都不用修改就直接可以在这两块板子上跑起来。

zepyhr是一个年轻的嵌入式实时系统，目前发展的很快，从源码里可以看到主要代码贡献者来自Wind River Systems、Intel和Nordic Semiconductor等。虽然zephyr是由C语言和汇编语言写成的，但是要完全掌握它还需要其他技能，比如python、cmake、dts等，而这几项技能恰恰是我之前都没怎么接触过的，所以在读到zephyr的编译过程这一块时有一种愕然止步的感觉，不过还好啦，不懂就学呗。

接下来我打算写一系列关于zephyr的随笔，涉及启动、线程、调度、驱动等，有时间的话还写一些网络协议相关的，比如蓝牙、thread等。

所使用的软、硬件平台如下：

软件：截止到目前为止最新的release版本（tag：v1.13.0）

硬件：STM32F103C8T6核心板（官方stm32_min_dev board），Cortex-M3（ARMv7-M）

二.启动过程分析

这篇随笔的目的就是要知道系统从上电到运行main()函数之前经历了什么过程。要知道启动过程，就得先从中断向量表入手，位于zephyr-zephyr-v1.13.0\arch\arm\core\cortex_m\ vector_table.S文件：

 #include <board.h>
 #include <toolchain.h>
 #include <linker/sections.h>
 #include <drivers/system_timer.h>
 #include "vector_table.h"

 _ASM_FILE_PROLOGUE

 GDATA(_main_stack)

11SECTION_SUBSEC_FUNC(exc_vector_table,_vector_table_section,_vector_table)

    /*
14     * setting the _very_ early boot on the main stack allows to use memset
15     * on the interrupt stack when CONFIG_INIT_STACKS is enabled before
16     * switching to the interrupt stack for the rest of the early boot
17     */
    .word _main_stack + CONFIG_MAIN_STACK_SIZE

    .word __reset
    .word __nmi

    .word __hard_fault
#if defined(CONFIG_ARMV6_M_ARMV8_M_BASELINE)
    .word __reserved
    .word __reserved
    .word __reserved
    .word __reserved
    .word __reserved
    .word __reserved
    .word __reserved
    .word __svc
    .word __reserved
#elif defined(CONFIG_ARMV7_M_ARMV8_M_MAINLINE)
    .word __mpu_fault
    .word __bus_fault
    .word __usage_fault
#if defined(CONFIG_ARM_SECURE_FIRMWARE)
    .word __secure_fault
#else
    .word __reserved
#endif /* CONFIG_ARM_SECURE_FIRMWARE */
    .word __reserved
    .word __reserved
    .word __reserved
    .word __svc
    .word __debug_monitor
#else
#error Unknown ARM architecture
#endif /* CONFIG_ARMV6_M_ARMV8_M_BASELINE */
    .word __reserved
    .word __pendsv
#if defined(CONFIG_CORTEX_M_SYSTICK)
    .word _timer_int_handler
#else
    .word __reserved
#endif

第20行就是CPU上电（复位）后执行的第一个函数__reset()，定义在zephyr-zephyr-v1.13.0\arch\arm\core\cortex_m\ reset.S：

 SECTION_SUBSEC_FUNC(TEXT,_reset_section,__reset)

 /*
4  * The entry point is located at the __reset symbol, which
5  * is fetched by a XIP image playing the role of a bootloader, which jumps to
6  * it, not through the reset vector mechanism. Such bootloaders might want to
7  * search for a __start symbol instead, so create that alias here.
8  */
 SECTION_SUBSEC_FUNC(TEXT,_reset_section,__start)

#if defined(CONFIG_PLATFORM_SPECIFIC_INIT)
    bl _PlatformInit
#endif

    /* lock interrupts: will get unlocked when switch to main task */
    movs.n r0, #_EXC_IRQ_DEFAULT_PRIO
    msr BASEPRI, r0

#ifdef CONFIG_WDOG_INIT
    /* board-specific watchdog initialization is necessary */
    bl _WdogInit
#endif

#ifdef CONFIG_INIT_STACKS
    ldr r0, =_interrupt_stack
    ldr r1, =0xaa
    ldr r2, =CONFIG_ISR_STACK_SIZE
    bl memset
#endif

    /*
32     * Set PSP and use it to boot without using MSP, so that it
33     * gets set to _interrupt_stack during initialisation.
34     */
    ldr r0, =_interrupt_stack
    ldr r1, =CONFIG_ISR_STACK_SIZE
    adds r0, r0, r1
    msr PSP, r0
    movs.n r0, #    /* switch to using PSP (bit1 of CONTROL reg) */
    msr CONTROL, r0
    /*
42     * When changing the stack pointer, software must use an ISB instruction
43     * immediately after the MSR instruction. This ensures that instructions
44     * after the ISB instruction execute using the new stack pointer.
45    */
    isb

    b _PrepC

在这里说一下，凡是以CONFIG开头的宏都是可以通过ninja menuconfig命令来进行配置的，就像linux下的make menuconfig命令一样。

第12行，如果定义了平台相关初始化操作则调用_PlatformInit()函数，这里没有定义。

第16~17行，屏蔽所有可以配置优先级的中断，_EXC_IRQ_DEFAULT_PRIO在这里的值为16。4位优先级位，即可以配置16种优先级级别（0~15，值越小优先级越高）。

第21行，如果定义了看门狗初始化，则调用_WdogInit()函数，这里没有定义。

第25~28行，初始化栈的内容为0xaa，是通过调用memset()函数来初始化的。其中_interrupt_stack是数组名，CONFIG_ISR_STACK_SIZE是数组的大小。目前来看，zephyr的栈空间都是通过静态数组的方式定义的。

第35~37行，r0的值就指向栈的顶端（因为栈是满递减方式的）。

第38行，将r0的值设置到PSP。

第39~40行，由MSP切换到PSP。

第46行，SP切换后必须加isb指令（ARM手册里有说明）。

第48行，调用_PrepC()函数，这是一个C语言写的函数，定义在zephyr-zephyr-v1.13.0\arch\arm\core\cortex_m\ prep_c.c：

 void _PrepC(void)
 {
     relocate_vector_table();
     enable_floating_point();
     _bss_zero();
     _data_copy();
 #ifdef CONFIG_BOOT_TIME_MEASUREMENT
     __start_time_stamp = ;
 #endif
    _Cstart();
    CODE_UNREACHABLE;
}

第3行，中断向量表重定位，如下定义：

 static inline void relocate_vector_table(void)
 {
     SCB->VTOR = VECTOR_ADDRESS & SCB_VTOR_TBLOFF_Msk;
     __DSB();
     __ISB();
 }

其中VECTOR_ADDRESS的值根据是否定义了CONFIG_XIP不同而不同，如果定义了CONFIG_XIP，那么VECTOR_ADDRESS的值就位0（ROM的起始地址），如果没有定义CONFIG_XIP，那么VECTOR_ADDRESS的值就位RAM的起始地址。对于stm32_min_dev板子是定义了CONFIG_XIP的。

第4行，由于STM32F103C8xx不带浮点功能，所以enable_floating_point()函数实际上没有任何操作。

第5行，调用_bss_zero()函数，定义在zephyr-zephyr-v1.13.0\kernel\init.c：

  void _bss_zero(void)
  {
      memset(&__bss_start, ,
           ((u32_t) &__bss_end - (u32_t) &__bss_start));
  #ifdef CONFIG_CCM_BASE_ADDRESS
      memset(&__ccm_bss_start, ,
          ((u32_t) &__ccm_bss_end - (u32_t) &__ccm_bss_start));
  #endif
  #ifdef CONFIG_APPLICATION_MEMORY
     memset(&__app_bss_start, ,
          ((u32_t) &__app_bss_end - (u32_t) &__app_bss_start));
 #endif
 }

即调用memset()函数，将全局未初始化变量清零。__bss_start、__bss_end是定义在链接脚本（zephyr-zephyr-v1.13.0\include\arch\arm\cortex_m\scripts\ linker.ld）里的。

第6行，调用_data_copy()函数，也是定义在zephyr-zephyr-v1.13.0\kernel\init.c：

  void _data_copy(void)
  {
      (void)memcpy(&__data_ram_start, &__data_rom_start,
           ((u32_t) &__data_ram_end - (u32_t) &__data_ram_start));
  }

即调用memcpy()函数，将全局已初始化变量从ROM拷贝到RAM里。__data_ram_start、__data_rom_start、__data_ram_end也是定义在链接脚本里的。

最后，第10行，调用_Cstart()函数，定义在zephyr-zephyr-v1.13.0\kernel\init.c：

 FUNC_NORETURN void _Cstart(void)
 {
     struct k_thread *dummy_thread = NULL;

     /*
6      * The interrupt library needs to be initialized early since a series
7      * of handlers are installed into the interrupt table to catch
8      * spurious interrupts. This must be performed before other kernel
9      * subsystems install bonafide handlers, or before hardware device
10     * drivers are initialized.
11     */

    _IntLibInit();

    /* perform any architecture-specific initialization */
    kernel_arch_init();

    /* perform basic hardware initialization */
    _sys_device_do_config_level(_SYS_INIT_LEVEL_PRE_KERNEL_1);
    _sys_device_do_config_level(_SYS_INIT_LEVEL_PRE_KERNEL_2);

    prepare_multithreading(dummy_thread);
    switch_to_main_thread();

    /*
26     * Compiler can't tell that the above routines won't return and issues
27     * a warning unless we explicitly tell it that control never gets this
28     * far.
29     */

    CODE_UNREACHABLE;
}

第13行，调用_IntLibInit()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\core\irq_init.c：

1void _IntLibInit(void)
{
    int irq = ;

    for (; irq < CONFIG_NUM_IRQS; irq++) {
        NVIC_SetPriority((IRQn_Type)irq, _IRQ_PRIO_OFFSET);
    }
}

其中，第6行_IRQ_PRIO_OFFSET的值1。意思就是将所有中断的优先级设为1（复位后默认的优先级0）。

第16行，调用kernel_arch_init()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\include\ kernel_arch_func.h：

 static ALWAYS_INLINE void kernel_arch_init(void)
 {
     _InterruptStackSetup();
     _ExcSetup();
     _FaultInit();
     _CpuIdleInit();
 }

全都是函数调用。

第3行，调用_InterruptStackSetup()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\include\cortex_m\ stack.h：

 static ALWAYS_INLINE void _InterruptStackSetup(void)
 {
     u32_t msp = (u32_t)(K_THREAD_STACK_BUFFER(_interrupt_stack) +
                 CONFIG_ISR_STACK_SIZE);

     __set_MSP(msp);
 }

即重新设置MSP的值，还记得在__reset()函数里也是用同样的值设置了PSP吗？

第4行，调用_ExcSetup()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\include\cortex_m\ exc.h：

 static ALWAYS_INLINE void _ExcSetup(void)
 {
     NVIC_SetPriority(PendSV_IRQn, 0xff);

     NVIC_SetPriority(SVCall_IRQn, _EXC_SVC_PRIO);

     NVIC_SetPriority(MemoryManagement_IRQn, _EXC_FAULT_PRIO);
     NVIC_SetPriority(BusFault_IRQn, _EXC_FAULT_PRIO);
     NVIC_SetPriority(UsageFault_IRQn, _EXC_FAULT_PRIO);

    /* Enable Usage, Mem, & Bus Faults */
    SCB->SHCSR |= SCB_SHCSR_USGFAULTENA_Msk | SCB_SHCSR_MEMFAULTENA_Msk |
              SCB_SHCSR_BUSFAULTENA_Msk;
}

设置各个异常的优先级，其中PendSV的优先级是最低的，SVCall、BusFault、UsageFault、MemoryManagement的优先级都为0。

第12~13行，使能BusFault、UsageFault、MemoryManagement异常中断。

回到kernel_arch_init()函数，第5行，调用_FaultInit()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\core\fault.c：

void _FaultInit(void)
{
    SCB->CCR |= SCB_CCR_DIV_0_TRP_Msk;
}

使能硬件相关的出错，比如0作为除数的错误操作。

回到kernel_arch_init()函数，第6行，调用_CpuIdleInit ()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\core\cpu_idle.S：

SECTION_FUNC(TEXT, _CpuIdleInit)
    ldr r1, =_SCB_SCR
    movs.n r2, #_SCR_INIT_BITS
    str r2, [r1]
    bx lr

将SCB_SCR寄存器的bit4置1，即当异常（中断）进入挂起状态后会被认为是一个WFE唤醒事件。

回到_Cstart()函数，第19~20行，都是调用_sys_device_do_config_level()函数，定义在zephyr-zephyr-v1.13.0\kernel\device.c：

  extern struct device __device_init_start[];
  extern struct device __device_PRE_KERNEL_1_start[];
  extern struct device __device_PRE_KERNEL_2_start[];
  extern struct device __device_POST_KERNEL_start[];
  extern struct device __device_APPLICATION_start[];
  extern struct device __device_init_end[];

  static struct device *config_levels[] = {
      __device_PRE_KERNEL_1_start,
     __device_PRE_KERNEL_2_start,
     __device_POST_KERNEL_start,
     __device_APPLICATION_start,
     /* End marker */
     __device_init_end,
 };

 void _sys_device_do_config_level(int level)
 {
     struct device *info;

     for (info = config_levels[level]; info < config_levels[level+];
                                 info++) {
         struct device_config *device = info->config;

         device->init(info);
         _k_object_init(info);
     }
 }

zephyr的设备（驱动）定义大部分都是使用DEVICE_AND_API_INIT这个宏，根据传入的参数，会把设备的结构体放入特定的段（section）里面，可以看到有四种类型（PRE_KERNEL_1、PRE_KERNEL_2、POST_KERNEL和APPLICATION），这也是系统跑起来时设备的初始化先后顺序。因此就可以知道，这里调用了PRE_KERNEL_1和PRE_KERNEL_2这两种类型的设备初始化函数。

回到_Cstart()函数，第22行，调用prepare_multithreading()函数，定义在zephyr-zephyr-v1.13.0\kernel\init.c：

  static void prepare_multithreading(struct k_thread *dummy_thread)
  {
      ARG_UNUSED(dummy_thread);

      /* _kernel.ready_q is all zeroes */
      _sched_init();

      _ready_q.cache = _main_thread;

     _setup_new_thread(_main_thread, _main_stack,
               MAIN_STACK_SIZE, bg_thread_main,
               NULL, NULL, NULL,
               CONFIG_MAIN_THREAD_PRIORITY, K_ESSENTIAL);

     sys_trace_thread_create(_main_thread);

     _mark_thread_as_started(_main_thread);
     _ready_thread(_main_thread);

     init_idle_thread(_idle_thread, _idle_stack);
     _kernel.cpus[].idle_thread = _idle_thread;
     sys_trace_thread_create(_idle_thread);

     initialize_timeouts();
 }

第6行，调用_sched_init()函数，初始化调度器，定义在zephyr-zephyr-v1.13.0\kernel\sched.c：

  void _sched_init(void)
  {
  #ifdef CONFIG_SCHED_DUMB
      sys_dlist_init(&_kernel.ready_q.runq);
  #endif

  #ifdef CONFIG_SCHED_SCALABLE
      _kernel.ready_q.runq = (struct _priq_rb) {
          .tree = {
             .lessthan_fn = _priq_rb_lessthan,
         }
     };
 #endif

 #ifdef CONFIG_SCHED_MULTIQ
     for (int i = ; i < ARRAY_SIZE(_kernel.ready_q.runq.queues); i++) {
         sys_dlist_init(&_kernel.ready_q.runq.queues[i]);
     }
 #endif

 #ifdef CONFIG_TIMESLICING
     k_sched_time_slice_set(CONFIG_TIMESLICE_SIZE,
         CONFIG_TIMESLICE_PRIORITY);
 #endif
 }

zephyr支持三种调度算法，分别是SCHED_DUMB（默认），即一个双向链表，SCHED_SCALABLE，即红黑树，SCHED_MULTIQ，即多队列。建议当线程数小于等于3时使用SCHED_DUMB，当线程数大于20时使用SCHED_SCALABLE。SCHED_SCALABLE的代码要比SCHED_DUMB多2K字节左右。SCHED_SCALABLE、SCHED_MULTIQ的速度都要比SCHED_DUMB快。另外，SCHED_MULTIQ是按优先级来存取的，目前最大只支持32个优先级。

由于默认是使用SCHED_DUMB，所以只关心第4行代码，就是初始化一个双向链表。zephyr中定义了很多结构体，如果全部拿出来分析的话，那篇幅就太大了，感兴趣的同学可以深入去学习，这里只是分析主要流程。

上面代码的第21~24行，时间片的初始化，当配置了时间片的值（大于0），并且线程的优先低于CONFIG_TIMESLICE_PRIORITY时，线程就会参与时间片轮转，即创建线程时会给它分配一个时间片，当时间片用完就把线程放到运行队列的最后。

回到prepare_multithreading()函数，第8行，_ready_q.cache永远指向下一个要投入运行的线程，这里是main线程。

第10~13行，调用_setup_new_thread()函数，每次创建线程时都会调用这个函数，定义在zephyr-zephyr-v1.13.0\kernel\thread.c：

  void _setup_new_thread(struct k_thread *new_thread,
                 k_thread_stack_t *stack, size_t stack_size,
                 k_thread_entry_t entry,
                 void *p1, void *p2, void *p3,
                 int prio, u32_t options)
  {
      stack_size = adjust_stack_size(stack_size);

      _new_thread(new_thread, stack, stack_size, entry, p1, p2, p3,
             prio, options);

     /* _current may be null if the dummy thread is not used */
     if (!_current) {
         new_thread->resource_pool = NULL;
         return;
     }

     new_thread->resource_pool = _current->resource_pool;
     sys_trace_thread_create(new_thread);
 }

第9~10行，调用_new_thread()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\core\thread.c：

 void _new_thread(struct k_thread *thread, k_thread_stack_t *stack,
          size_t stackSize, k_thread_entry_t pEntry,
          void *parameter1, void *parameter2, void *parameter3,
          int priority, unsigned int options)
 {
     char *pStackMem = K_THREAD_STACK_BUFFER(stack);

     _ASSERT_VALID_PRIO(priority, pEntry);

    char *stackEnd = pStackMem + stackSize;

    struct __esf *pInitCtx;

    _new_thread_init(thread, pStackMem, stackEnd - pStackMem, priority,
             options);

    /* carve the thread entry struct from the "base" of the stack */
    pInitCtx = (struct __esf *)(STACK_ROUND_DOWN(stackEnd -
                             sizeof(struct __esf)));

    pInitCtx->pc = (u32_t)_thread_entry;

    /* force ARM mode by clearing LSB of address */
    pInitCtx->pc &= 0xfffffffe;

    pInitCtx->a1 = (u32_t)pEntry;
    pInitCtx->a2 = (u32_t)parameter1;
    pInitCtx->a3 = (u32_t)parameter2;
    pInitCtx->a4 = (u32_t)parameter3;
    pInitCtx->xpsr =
        0x01000000UL; /* clear all, thumb bit is 1, even if RO */

    thread->callee_saved.psp = (u32_t)pInitCtx;
    thread->arch.basepri = ;

    /* swap_return_value can contain garbage */

    /*
39     * initial values in all other registers/thread entries are
40     * irrelevant.
41     */
}

第6行，得到线程栈的起始地址。

第10行，指向线程栈的最高地址。

第14~15行，调用_new_thread_init()函数，定义在zephyr-zephyr-v1.13.0\kernel\include\kernel_structs.h：

 static ALWAYS_INLINE void _new_thread_init(struct k_thread *thread,
                         char *pStack, size_t stackSize,
                         int prio, unsigned int options)
 {
     ARG_UNUSED(pStack);
     ARG_UNUSED(stackSize);

     /* Initialize various struct k_thread members */
     _init_thread_base(&thread->base, prio, _THREAD_PRESTART, options);

    /* static threads overwrite it afterwards with real value */
    thread->init_data = NULL;
    thread->fn_abort = NULL;
}

第9行，调用_init_thread_base()函数，定义在zephyr-zephyr-v1.13.0\kernel\thread.c：

 void _init_thread_base(struct _thread_base *thread_base, int priority,
                u32_t initial_state, unsigned int options)
 {
     /* k_q_node is initialized upon first insertion in a list */

     thread_base->user_options = (u8_t)options;
     thread_base->thread_state = (u8_t)initial_state;

     thread_base->prio = priority;

    thread_base->sched_locked = ;

    /* swap_data does not need to be initialized */

    _init_thread_timeout(thread_base);
}

第7行，设置线程的状态，有以下这些类型：

/* Not a real thread */
#define _THREAD_DUMMY (BIT(0))

/* Thread is waiting on an object */
#define _THREAD_PENDING (BIT(1))

/* Thread has not yet started */
#define _THREAD_PRESTART (BIT(2))

/* Thread has terminated */
#define _THREAD_DEAD (BIT(3))

/* Thread is suspended */
#define _THREAD_SUSPENDED (BIT(4))

/* Thread is present in the ready queue */
#define _THREAD_QUEUED (BIT(6))

第9行，设置线程的优先级。

第15行，调用_init_thread_timeout()函数，定义在zephyr-zephyr-v1.13.0\kernel\include\timeout_q.h：

  static inline void _init_timeout(struct _timeout *t, _timeout_func_t func)
  {
      /*
4       * Must be initialized here and when dequeueing a timeout so that code
5       * not dealing with timeouts does not have to handle this, such as when
6       * waiting forever on a semaphore.
7       */
      t->delta_ticks_from_prev = _INACTIVE;

     /*
11      * Must be initialized here so that k_wakeup can
12      * verify the thread is not on a wait queue before aborting a timeout.
13      */
     t->wait_q = NULL;

     /*
17      * Must be initialized here, so the _handle_one_timeout()
18      * routine can check if there is a thread waiting on this timeout
19      */
     t->thread = NULL;

     /*
23      * Function must be initialized before being potentially called.
24      */
     t->func = func;

     /*
28      * These are initialized when enqueing on the timeout queue:
29      *
30      *   thread->timeout.node.next
31      *   thread->timeout.node.prev
32      */
 }

 static ALWAYS_INLINE void
 _init_thread_timeout(struct _thread_base *thread_base)
 {
     _init_timeout(&thread_base->timeout, NULL);
 }

回到_new_thread()函数，第18~19行，由于CortexM系列的栈是以满递减方式增长的，所以这里将栈顶地址进行8字节向下对齐。

第21行，PC指向_thread_entry()函数入口地址，线程运行时不是直接调用线程函数的，而是调用_thread_entry()函数，再通过_thread_entry()函数调用真正的线程函数。

第24行，以ARM模式运行_thread_entry()函数。

第26~29行，线程入口函数和参数，这里只支持最多3个线程参数。

第30~31行，thumb位必须为1。

第33行，保存栈顶地址。

好了，可以回到prepare_multithreading()函数了，第17行，调用_mark_thread_as_started()函数，定义在zephyr-zephyr-v1.13.0\kernel\include\ ksched.h：

static inline void _mark_thread_as_started(struct k_thread *thread)
{
    thread->base.thread_state &= ~_THREAD_PRESTART;
}

刚才创建线程时把线程状态设为了_THREAD_PRESTART，这里就把它清掉了。

回到prepare_multithreading()函数了，第18行，调用_ready_thread()函数，定义在zephyr-zephyr-v1.13.0\kernel\include\ ksched.h：

 static inline int _is_thread_prevented_from_running(struct k_thread *thread)
 {
     u8_t state = thread->base.thread_state;

     return state & (_THREAD_PENDING | _THREAD_PRESTART | _THREAD_DEAD |
             _THREAD_DUMMY | _THREAD_SUSPENDED);

 }
static inline int _is_thread_timeout_active(struct k_thread *thread)
{
    return thread->base.timeout.delta_ticks_from_prev != _INACTIVE;
}
static inline int _is_thread_ready(struct k_thread *thread)
{
    return !(_is_thread_prevented_from_running(thread) ||
         _is_thread_timeout_active(thread));
}
static inline void _ready_thread(struct k_thread *thread)
{
    if (_is_thread_ready(thread)) {
        _add_thread_to_ready_q(thread);
    }

    sys_trace_thread_ready(thread);
}

第23行，调用_is_thread_ready()函数，从前面的分析可以知道，_is_thread_prevented_from_running()函数返回值为0，而_is_thread_timeout_active()函数的返回值1，因此第23行的if条件成立，调用第24行的_add_thread_to_ready_q()函数，定义在

zephyr-zephyr-v1.13.0\kernel\ sched.c：

  void _add_thread_to_ready_q(struct k_thread *thread)
  {
      LOCKED(&sched_lock) {
          _priq_run_add(&_kernel.ready_q.runq, thread);
          _mark_thread_as_queued(thread);
          update_cache();
      }
  }

第4行，调用_priq_run_add()函数，对于使用SCHED_DUMB调度算法，实际上调用的是_priq_dumb_add()函数，定义在zephyr-zephyr-v1.13.0\kernel\ sched.c：

  void _priq_dumb_add(sys_dlist_t *pq, struct k_thread *thread)
  {
      struct k_thread *t;

      __ASSERT_NO_MSG(!_is_idle(thread));

      SYS_DLIST_FOR_EACH_CONTAINER(pq, t, base.qnode_dlist) {
          if (_is_t1_higher_prio_than_t2(thread, t)) {
              sys_dlist_insert_before(pq, &t->base.qnode_dlist,
                         &thread->base.qnode_dlist);
             return;
         }
     }

     sys_dlist_append(pq, &thread->base.qnode_dlist);
 }

即遍历就绪队列链表，将当前线程按优先级由高到低插入到该链表中。

回到_add_thread_to_ready_q()函数，第5行，调用_mark_thread_as_queued()函数，定义在

zephyr-zephyr-v1.13.0\kernel\include\ ksched.h：

  static inline void _set_thread_states(struct k_thread *thread, u32_t states)
  {
      thread->base.thread_state |= states;
  }

  static inline void _mark_thread_as_queued(struct k_thread *thread)
  {
      _set_thread_states(thread, _THREAD_QUEUED);
  }

即设置线程的状态为_THREAD_QUEUED。

回到_add_thread_to_ready_q()函数，第6行，调用update_cache ()函数，定义在zephyr-zephyr-v1.13.0\kernel\ sched.c：

  static void update_cache(int preempt_ok)
  {
      struct k_thread *th = next_up();

      if (should_preempt(th, preempt_ok)) {
          _kernel.ready_q.cache = th;
      } else {
          _kernel.ready_q.cache = _current;
      }
 }

第3行，调用next_up()函数，定义在zephyr-zephyr-v1.13.0\kernel\ sched.c：

  static struct k_thread *next_up(void)
  {
      struct k_thread *th = _priq_run_best(&_kernel.ready_q.runq);

      return th ? th : _current_cpu->idle_thread;
  }

第3行，调用_priq_run_best()函数，实际上调用的是_priq_dumb_best()函数，定义在zephyr-zephyr-v1.13.0\kernel\ sched.c：

struct k_thread *_priq_dumb_best(sys_dlist_t *pq)
{
    return CONTAINER_OF(sys_dlist_peek_head(pq),
                struct k_thread, base.qnode_dlist);
}

调用sys_dlist_peek_head()函数得到就绪队列的头节点，也即得到优先级最高的线程。

next_up()函数的第5行，前面已经将main线程加入到就绪队列里了，因此返回的就是main线程，而不是空闲线程，更可况空闲线程还没进行初始化（创建）呢。

回到update_cache()函数，第5行，调用should_preempt()函数，定义在zephyr-zephyr-v1.13.0\kernel\ sched.c：

  static int should_preempt(struct k_thread *th, int preempt_ok)
  {
      /* Preemption is OK if it's being explicitly allowed by
4       * software state (e.g. the thread called k_yield())
5       */
      if (preempt_ok) {
          return ;
      }

     /* Or if we're pended/suspended/dummy (duh) */
     if (!_current || !_is_thread_ready(_current)) {
         return ;
     }

     /* Otherwise we have to be running a preemptible thread or
16      * switching to a metairq
17      */
     if (_is_preempt(_current) || is_metairq(th)) {
         return ;
     }

     /* The idle threads can look "cooperative" if there are no
23      * preemptible priorities (this is sort of an API glitch).
24      * They must always be preemptible.
25      */
     if (_is_idle(_current)) {
         return ;
     }

     return ;
 }

第6行，因为传进来的preempt_ok的值为0，所以if条件不成立。

第11行，到目前为止，_current的值没有被初始化过，所以if条件成立，返回1。_current指向当前线程。

回到update_cache()函数，第6行，_kernel.ready_q.cache就指向了main线程。

好了，回到prepare_multithreading()函数，第20行，调用init_idle_thread()函数，定义在zephyr-zephyr-v1.13.0\kernel\init.c：

  static void init_idle_thread(struct k_thread *thr, k_thread_stack_t *stack)
  {
      _setup_new_thread(thr, stack,
                IDLE_STACK_SIZE, idle, NULL, NULL, NULL,
                K_LOWEST_THREAD_PRIO, K_ESSENTIAL);
      _mark_thread_as_started(thr);
  }

里面调用的这两个函数前面已经分析过了。

prepare_multithreading()函数的第24行，调用initialize_timeouts()函数，定义在zephyr-zephyr-v1.13.0\kernel\init.c：

    #define initialize_timeouts() do { \
        sys_dlist_init(&_timeout_q); \
    } while (())

即初始化_timeout_q这个双向链表。

到这里，prepare_multithreading()函数也分析完了，回到_Cstart()函数，第23行，调用switch_to_main_thread()函数，定义在zephyr-zephyr-v1.13.0\kernel\init.c：

static void switch_to_main_thread(void)
{
    _arch_switch_to_main_thread(_main_thread, _main_stack, MAIN_STACK_SIZE,
                    bg_thread_main);
}

调用_arch_switch_to_main_thread()函数，定义在zephyr-zephyr-v1.13.0\arch\arm\include\ kernel_arch_func.h：

 static ALWAYS_INLINE void
 _arch_switch_to_main_thread(struct k_thread *main_thread,
                 k_thread_stack_t *main_stack,
                 size_t main_stack_size, k_thread_entry_t _main)
 {
     /* get high address of the stack, i.e. its start (stack grows down) */
     char *start_of_main_stack;

     start_of_main_stack =
        K_THREAD_STACK_BUFFER(main_stack) + main_stack_size;

    start_of_main_stack = (void *)STACK_ROUND_DOWN(start_of_main_stack);

    _current = main_thread;

    /* the ready queue cache already contains the main thread */

    __asm__ __volatile__(

        /* move to main() thread stack */
        "msr PSP, %0 \t\n"

        /* unlock interrupts */
        "movs %%r1, #0 \n\t"
        "msr BASEPRI, %%r1 \n\t"

        /* branch to _thread_entry(_main, 0, 0, 0) */
        "mov %%r0, %1 \n\t"
        "bx %2 \t\n"

        /* never gets here */

        :
        : "r"(start_of_main_stack),
          "r"(_main), "r"(_thread_entry),
          "r"(main_thread)

        : "r0", "r1", "sp"
    );

    CODE_UNREACHABLE;
}

第9~12行，得到main线程的栈顶地址（8字节向下对齐后的）。

第14行，_current指向main线程。

第18行，通过C语言内嵌汇编，设置PSP的值为start_of_main_stack，设置BASEPRI寄存器的值为0，最后调用_thread_entry()函数，第一个参数为_main。

接下来看一下_thread_entry()函数，定义在zephyr-zephyr-v1.13.0\lib\ thread_entry.c：

 FUNC_NORETURN void _thread_entry(k_thread_entry_t entry,
                  void *p1, void *p2, void *p3)
 {
     entry(p1, p2, p3);

     k_thread_abort(k_current_get());

     /*
9      * Compiler can't tell that k_thread_abort() won't return and issues a
10     * warning unless we tell it that control never gets this far.
11     */

    CODE_UNREACHABLE;
}

第4行，实际上调用的是bg_thread_main()函数，定义在zephyr-zephyr-v1.13.0\kernel\init.c：

  static void bg_thread_main(void *unused1, void *unused2, void *unused3)
  {
      ARG_UNUSED(unused1);
      ARG_UNUSED(unused2);
      ARG_UNUSED(unused3);

      _sys_device_do_config_level(_SYS_INIT_LEVEL_POST_KERNEL);

      if (boot_delay > ) {
         printk("***** delaying boot " STRINGIFY(CONFIG_BOOT_DELAY)
                "ms (per build configuration) *****\n");
         k_busy_wait(CONFIG_BOOT_DELAY * USEC_PER_MSEC);
     }
     PRINT_BOOT_BANNER();

     /* Final init level before app starts */
     _sys_device_do_config_level(_SYS_INIT_LEVEL_APPLICATION);

     _init_static_threads();

     extern void main(void);

     main();

     /* Terminate thread normally since it has no more work to do */
     _main_thread->base.user_options &= ~K_ESSENTIAL;
 }

第7行，初始化POST_KERNEL类别的设备，前面已经分析过类似的了。

第9行，如果配置了启动延时，则调用k_busy_wait()函数，这是一个忙等待函数，会一致占用着CPU。

第14行，打印启动“横幅”。即打印出前面开发环境搭建随笔里hello world之前一行的打印。

第17行，初始化APPLICATION类别的设备，前面已经分析过类似的了。

第19行，调用_init_static_threads()函数，定义在zephyr-zephyr-v1.13.0\kernel\thread.c：

 void _init_static_threads(void)
 {
     unsigned int  key;

     _FOREACH_STATIC_THREAD(thread_data) {
         _setup_new_thread(
             thread_data->init_thread,
             thread_data->init_stack,
             thread_data->init_stack_size,
            thread_data->init_entry,
            thread_data->init_p1,
            thread_data->init_p2,
            thread_data->init_p3,
            thread_data->init_prio,
            thread_data->init_options);

        thread_data->init_thread->init_data = thread_data;
    }

    _sched_lock();

    /*
23     * Non-legacy static threads may be started immediately or after a
24     * previously specified delay. Even though the scheduler is locked,
25     * ticks can still be delivered and processed. Lock interrupts so
26     * that the countdown until execution begins from the same tick.
27     *
28     * Note that static threads defined using the legacy API have a
29     * delay of K_FOREVER.
30     */
    key = irq_lock();
    _FOREACH_STATIC_THREAD(thread_data) {
        if (thread_data->init_delay != K_FOREVER) {
            schedule_new_thread(thread_data->init_thread,
                        thread_data->init_delay);
        }
    }
    irq_unlock(key);
    k_sched_unlock();
}

zephyr支持两种创建线程的方式，分别是静态创建和动态创建，静态创建使用K_THREAD_DEFINE宏，动态创建则调用k_thread_create()函数。

第5行，遍历所有静态创建的线程，调用_setup_new_thread()函数。

第32行，遍历所有静态创建的线程，如果创建的静态线程延时不为K_FOREVER（也即线程需要延时一段时间之后才参与调度），那么就将该线程加入到超时队列里，具体过程将在后面的随笔里再分析，敬请期待。

最后就是调用我们最熟悉的main()函数了。