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文件：

1 #include 
2 #include 
3 #include 
4 #include 
5 #include "vector_table.h"
6 
7 _ASM_FILE_PROLOGUE
8 
9 GDATA(_main_stack)
10
11SECTION_SUBSEC_FUNC(exc_vector_table,_vector_table_section,_vector_table)
12
13    /*
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     */
18    .word _main_stack + CONFIG_MAIN_STACK_SIZE
19
20    .word __reset
21    .word __nmi
22
23    .word __hard_fault
24#if defined(CONFIG_ARMV6_M_ARMV8_M_BASELINE)
25    .word __reserved
26    .word __reserved
27    .word __reserved
28    .word __reserved
29    .word __reserved
30    .word __reserved
31    .word __reserved
32    .word __svc
33    .word __reserved
34#elif defined(CONFIG_ARMV7_M_ARMV8_M_MAINLINE)
35    .word __mpu_fault
36    .word __bus_fault
37    .word __usage_fault
38#if defined(CONFIG_ARM_SECURE_FIRMWARE)
39    .word __secure_fault
40#else
41    .word __reserved
42#endif /* CONFIG_ARM_SECURE_FIRMWARE */
43    .word __reserved
44    .word __reserved
45    .word __reserved
46    .word __svc
47    .word __debug_monitor
48#else
49#error Unknown ARM architecture
50#endif /* CONFIG_ARMV6_M_ARMV8_M_BASELINE */
51    .word __reserved
52    .word __pendsv
53#if defined(CONFIG_CORTEX_M_SYSTICK)
54    .word _timer_int_handler
55#else
56    .word __reserved
57#endif

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

1 SECTION_SUBSEC_FUNC(TEXT,_reset_section,__reset)
2 
3 /*
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  */
9 SECTION_SUBSEC_FUNC(TEXT,_reset_section,__start)
10
11#if defined(CONFIG_PLATFORM_SPECIFIC_INIT)
12    bl _PlatformInit
13#endif
14
15    /* lock interrupts: will get unlocked when switch to main task */
16    movs.n r0, #_EXC_IRQ_DEFAULT_PRIO
17    msr BASEPRI, r0
18
19#ifdef CONFIG_WDOG_INIT
20    /* board-specific watchdog initialization is necessary */
21    bl _WdogInit
22#endif
23
24#ifdef CONFIG_INIT_STACKS
25    ldr r0, =_interrupt_stack
26    ldr r1, =0xaa
27    ldr r2, =CONFIG_ISR_STACK_SIZE
28    bl memset
29#endif
30
31    /*
32     * Set PSP and use it to boot without using MSP, so that it
33     * gets set to _interrupt_stack during initialisation.
34     */
35    ldr r0, =_interrupt_stack
36    ldr r1, =CONFIG_ISR_STACK_SIZE
37    adds r0, r0, r1
38    msr PSP, r0
39    movs.n r0, #2    /* switch to using PSP (bit1 of CONTROL reg) */
40    msr CONTROL, r0
41    /*
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    */
46    isb
47
48    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：

1 void _PrepC(void)
2 {
3     relocate_vector_table();
4     enable_floating_point();
5     _bss_zero();
6     _data_copy();
7 #ifdef CONFIG_BOOT_TIME_MEASUREMENT
8     __start_time_stamp = 0;
9 #endif
10    _Cstart();
11    CODE_UNREACHABLE;
12}

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

1 static inline void relocate_vector_table(void)
2 {
3     SCB->VTOR = VECTOR_ADDRESS & SCB_VTOR_TBLOFF_Msk;
4     __DSB();
5     __ISB();
6 }

其中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：

1  void _bss_zero(void)
2  {
3      memset(&__bss_start, 0,
4           ((u32_t) &__bss_end - (u32_t) &__bss_start));
5  #ifdef CONFIG_CCM_BASE_ADDRESS
6      memset(&__ccm_bss_start, 0,
7          ((u32_t) &__ccm_bss_end - (u32_t) &__ccm_bss_start));
8  #endif
9  #ifdef CONFIG_APPLICATION_MEMORY
10     memset(&__app_bss_start, 0,
11          ((u32_t) &__app_bss_end - (u32_t) &__app_bss_start));
12 #endif
13 }

即调用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：

1  void _data_copy(void)
2  {
3      (void)memcpy(&__data_ram_start, &__data_rom_start,
4           ((u32_t) &__data_ram_end - (u32_t) &__data_ram_start));
5  }

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

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

1 FUNC_NORETURN void _Cstart(void)
2 {
3     struct k_thread *dummy_thread = NULL;
4 
5     /*
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     */
12
13    _IntLibInit();
14
15    /* perform any architecture-specific initialization */
16    kernel_arch_init();
17
18    /* perform basic hardware initialization */
19    _sys_device_do_config_level(_SYS_INIT_LEVEL_PRE_KERNEL_1);
20    _sys_device_do_config_level(_SYS_INIT_LEVEL_PRE_KERNEL_2);
21
22    prepare_multithreading(dummy_thread);
23    switch_to_main_thread();
24
25    /*
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     */
30
31    CODE_UNREACHABLE;
32}

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

1void _IntLibInit(void)
2{
3    int irq = 0;
4
5    for (; irq < CONFIG_NUM_IRQS; irq++) {
6        NVIC_SetPriority((IRQn_Type)irq, _IRQ_PRIO_OFFSET);
7    }
8}

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

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

1 static ALWAYS_INLINE void kernel_arch_init(void)
2 {
3     _InterruptStackSetup();
4     _ExcSetup();
5     _FaultInit();
6     _CpuIdleInit();
7 }

全都是函数调用。

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

1 static ALWAYS_INLINE void _InterruptStackSetup(void)
2 {
3     u32_t msp = (u32_t)(K_THREAD_STACK_BUFFER(_interrupt_stack) +
4                 CONFIG_ISR_STACK_SIZE);
5 
6     __set_MSP(msp);
7 }

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

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

1 static ALWAYS_INLINE void _ExcSetup(void)
2 {
3     NVIC_SetPriority(PendSV_IRQn, 0xff);
4 
5     NVIC_SetPriority(SVCall_IRQn, _EXC_SVC_PRIO);
6 
7     NVIC_SetPriority(MemoryManagement_IRQn, _EXC_FAULT_PRIO);
8     NVIC_SetPriority(BusFault_IRQn, _EXC_FAULT_PRIO);
9     NVIC_SetPriority(UsageFault_IRQn, _EXC_FAULT_PRIO);
10
11    /* Enable Usage, Mem, & Bus Faults */
12    SCB->SHCSR |= SCB_SHCSR_USGFAULTENA_Msk | SCB_SHCSR_MEMFAULTENA_Msk |
13              SCB_SHCSR_BUSFAULTENA_Msk;
14}

设置各个异常的优先级，其中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：

1  extern struct device __device_init_start[];
2  extern struct device __device_PRE_KERNEL_1_start[];
3  extern struct device __device_PRE_KERNEL_2_start[];
4  extern struct device __device_POST_KERNEL_start[];
5  extern struct device __device_APPLICATION_start[];
6  extern struct device __device_init_end[];
7  
8  static struct device *config_levels[] = {
9      __device_PRE_KERNEL_1_start,
10     __device_PRE_KERNEL_2_start,
11     __device_POST_KERNEL_start,
12     __device_APPLICATION_start,
13     /* End marker */
14     __device_init_end,
15 };
16 
17 void _sys_device_do_config_level(int level)
18 {
19     struct device *info;
20 
21     for (info = config_levels[level]; info < config_levels[level+1];
22                                 info++) {
23         struct device_config *device = info->config;
24 
25         device->init(info);
26         _k_object_init(info);
27     }
28 }

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：

1  static void prepare_multithreading(struct k_thread *dummy_thread)
2  {
3      ARG_UNUSED(dummy_thread);
4  
5      /* _kernel.ready_q is all zeroes */
6      _sched_init();
7  
8      _ready_q.cache = _main_thread;
9  
10     _setup_new_thread(_main_thread, _main_stack,
11               MAIN_STACK_SIZE, bg_thread_main,
12               NULL, NULL, NULL,
13               CONFIG_MAIN_THREAD_PRIORITY, K_ESSENTIAL);
14 
15     sys_trace_thread_create(_main_thread);
16 
17     _mark_thread_as_started(_main_thread);
18     _ready_thread(_main_thread);
19 
20     init_idle_thread(_idle_thread, _idle_stack);
21     _kernel.cpus[0].idle_thread = _idle_thread;
22     sys_trace_thread_create(_idle_thread);
23 
24     initialize_timeouts();
25 }

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

1  void _sched_init(void)
2  {
3  #ifdef CONFIG_SCHED_DUMB
4      sys_dlist_init(&_kernel.ready_q.runq);
5  #endif
6  
7  #ifdef CONFIG_SCHED_SCALABLE
8      _kernel.ready_q.runq = (struct _priq_rb) {
9          .tree = {
10             .lessthan_fn = _priq_rb_lessthan,
11         }
12     };
13 #endif
14 
15 #ifdef CONFIG_SCHED_MULTIQ
16     for (int i = 0; i < ARRAY_SIZE(_kernel.ready_q.runq.queues); i++) {
17         sys_dlist_init(&_kernel.ready_q.runq.queues[i]);
18     }
19 #endif
20 
21 #ifdef CONFIG_TIMESLICING
22     k_sched_time_slice_set(CONFIG_TIMESLICE_SIZE,
23         CONFIG_TIMESLICE_PRIORITY);
24 #endif
25 }

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：

1  void _setup_new_thread(struct k_thread *new_thread,
2                 k_thread_stack_t *stack, size_t stack_size,
3                 k_thread_entry_t entry,
4                 void *p1, void *p2, void *p3,
5                 int prio, u32_t options)
6  {
7      stack_size = adjust_stack_size(stack_size);
8  
9      _new_thread(new_thread, stack, stack_size, entry, p1, p2, p3,
10             prio, options);
11 
12     /* _current may be null if the dummy thread is not used */
13     if (!_current) {
14         new_thread->resource_pool = NULL;
15         return;
16     }
17 
18     new_thread->resource_pool = _current->resource_pool;
19     sys_trace_thread_create(new_thread);
20 }

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

1 void _new_thread(struct k_thread *thread, k_thread_stack_t *stack,
2          size_t stackSize, k_thread_entry_t pEntry,
3          void *parameter1, void *parameter2, void *parameter3,
4          int priority, unsigned int options)
5 {
6     char *pStackMem = K_THREAD_STACK_BUFFER(stack);
7 
8     _ASSERT_VALID_PRIO(priority, pEntry);
9 
10    char *stackEnd = pStackMem + stackSize;
11
12    struct __esf *pInitCtx;
13
14    _new_thread_init(thread, pStackMem, stackEnd - pStackMem, priority,
15             options);
16
17    /* carve the thread entry struct from the "base" of the stack */
18    pInitCtx = (struct __esf *)(STACK_ROUND_DOWN(stackEnd -
19                             sizeof(struct __esf)));
20
21    pInitCtx->pc = (u32_t)_thread_entry;
22
23    /* force ARM mode by clearing LSB of address */
24    pInitCtx->pc &= 0xfffffffe;
25
26    pInitCtx->a1 = (u32_t)pEntry;
27    pInitCtx->a2 = (u32_t)parameter1;
28    pInitCtx->a3 = (u32_t)parameter2;
29    pInitCtx->a4 = (u32_t)parameter3;
30    pInitCtx->xpsr =
31        0x01000000UL; /* clear all, thumb bit is 1, even if RO */
32
33    thread->callee_saved.psp = (u32_t)pInitCtx;
34    thread->arch.basepri = 0;
35
36    /* swap_return_value can contain garbage */
37
38    /*
39     * initial values in all other registers/thread entries are
40     * irrelevant.
41     */
42}

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

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

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

1 static ALWAYS_INLINE void _new_thread_init(struct k_thread *thread,
2                         char *pStack, size_t stackSize,
3                         int prio, unsigned int options)
4 {
5     ARG_UNUSED(pStack);
6     ARG_UNUSED(stackSize);
7 
8     /* Initialize various struct k_thread members */
9     _init_thread_base(&thread->base, prio, _THREAD_PRESTART, options);
10
11    /* static threads overwrite it afterwards with real value */
12    thread->init_data = NULL;
13    thread->fn_abort = NULL;
14}

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

1 void _init_thread_base(struct _thread_base *thread_base, int priority,
2                u32_t initial_state, unsigned int options)
3 {
4     /* k_q_node is initialized upon first insertion in a list */
5 
6     thread_base->user_options = (u8_t)options;
7     thread_base->thread_state = (u8_t)initial_state;
8 
9     thread_base->prio = priority;
10
11    thread_base->sched_locked = 0;
12
13    /* swap_data does not need to be initialized */
14
15    _init_thread_timeout(thread_base);
16}

第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：

1  static inline void _init_timeout(struct _timeout *t, _timeout_func_t func)
2  {
3      /*
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       */
8      t->delta_ticks_from_prev = _INACTIVE;
9  
10     /*
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      */
14     t->wait_q = NULL;
15 
16     /*
17      * Must be initialized here, so the _handle_one_timeout()
18      * routine can check if there is a thread waiting on this timeout
19      */
20     t->thread = NULL;
21 
22     /*
23      * Function must be initialized before being potentially called.
24      */
25     t->func = func;
26 
27     /*
28      * These are initialized when enqueing on the timeout queue:
29      *
30      *   thread->timeout.node.next
31      *   thread->timeout.node.prev
32      */
33 }
34 
35 static ALWAYS_INLINE void
36 _init_thread_timeout(struct _thread_base *thread_base)
37 {
38     _init_timeout(&thread_base->timeout, NULL);
39 }

回到_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：

1 static inline int _is_thread_prevented_from_running(struct k_thread *thread)
2 {
3     u8_t state = thread->base.thread_state;
4 
5     return state & (_THREAD_PENDING | _THREAD_PRESTART | _THREAD_DEAD |
6             _THREAD_DUMMY | _THREAD_SUSPENDED);
7 
8 }
9 
10static inline int _is_thread_timeout_active(struct k_thread *thread)
11{
12    return thread->base.timeout.delta_ticks_from_prev != _INACTIVE;
13}
14
15static inline int _is_thread_ready(struct k_thread *thread)
16{
17    return !(_is_thread_prevented_from_running(thread) ||
18         _is_thread_timeout_active(thread));
19}
20
21static inline void _ready_thread(struct k_thread *thread)
22{
23    if (_is_thread_ready(thread)) {
24        _add_thread_to_ready_q(thread);
25    }
26
27    sys_trace_thread_ready(thread);
28}

第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：

1  void _add_thread_to_ready_q(struct k_thread *thread)
2  {
3      LOCKED(&sched_lock) {
4          _priq_run_add(&_kernel.ready_q.runq, thread);
5          _mark_thread_as_queued(thread);
6          update_cache(0);
7      }
8  }

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

1  void _priq_dumb_add(sys_dlist_t *pq, struct k_thread *thread)
2  {
3      struct k_thread *t;
4  
5      __ASSERT_NO_MSG(!_is_idle(thread));
6  
7      SYS_DLIST_FOR_EACH_CONTAINER(pq, t, base.qnode_dlist) {
8          if (_is_t1_higher_prio_than_t2(thread, t)) {
9              sys_dlist_insert_before(pq, &t->base.qnode_dlist,
10                         &thread->base.qnode_dlist);
11             return;
12         }
13     }
14 
15     sys_dlist_append(pq, &thread->base.qnode_dlist);
16 }

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

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

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

1  static inline void _set_thread_states(struct k_thread *thread, u32_t states)
2  {
3      thread->base.thread_state |= states;
4  }
5  
6  static inline void _mark_thread_as_queued(struct k_thread *thread)
7  {
8      _set_thread_states(thread, _THREAD_QUEUED);
9  }

即设置线程的状态为_THREAD_QUEUED。

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

1  static void update_cache(int preempt_ok)
2  {
3      struct k_thread *th = next_up();
4  
5      if (should_preempt(th, preempt_ok)) {
6          _kernel.ready_q.cache = th;
7      } else {
8          _kernel.ready_q.cache = _current;
9      }
10 }

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

1  static struct k_thread *next_up(void)
2  {
3      struct k_thread *th = _priq_run_best(&_kernel.ready_q.runq);
4  
5      return th ? th : _current_cpu->idle_thread;
6  }

第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：

1  static int should_preempt(struct k_thread *th, int preempt_ok)
2  {
3      /* Preemption is OK if it's being explicitly allowed by
4       * software state (e.g. the thread called k_yield())
5       */
6      if (preempt_ok) {
7          return 1;
8      }
9  
10     /* Or if we're pended/suspended/dummy (duh) */
11     if (!_current || !_is_thread_ready(_current)) {
12         return 1;
13     }
14 
15     /* Otherwise we have to be running a preemptible thread or
16      * switching to a metairq
17      */
18     if (_is_preempt(_current) || is_metairq(th)) {
19         return 1;
20     }
21 
22     /* 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      */
26     if (_is_idle(_current)) {
27         return 1;
28     }
29 
30     return 0;
31 }

第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：

1  static void init_idle_thread(struct k_thread *thr, k_thread_stack_t *stack)
2  {
3      _setup_new_thread(thr, stack,
4                IDLE_STACK_SIZE, idle, NULL, NULL, NULL,
5                K_LOWEST_THREAD_PRIO, K_ESSENTIAL);
6      _mark_thread_as_started(thr);
7  }

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

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

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

即初始化_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：

1 static ALWAYS_INLINE void
2 _arch_switch_to_main_thread(struct k_thread *main_thread,
3                 k_thread_stack_t *main_stack,
4                 size_t main_stack_size, k_thread_entry_t _main)
5 {
6     /* get high address of the stack, i.e. its start (stack grows down) */
7     char *start_of_main_stack;
8 
9     start_of_main_stack =
10        K_THREAD_STACK_BUFFER(main_stack) + main_stack_size;
11
12    start_of_main_stack = (void *)STACK_ROUND_DOWN(start_of_main_stack);
13
14    _current = main_thread;
15
16    /* the ready queue cache already contains the main thread */
17
18    __asm__ __volatile__(
19
20        /* move to main() thread stack */
21        "msr PSP, %0 \t\n"
22
23        /* unlock interrupts */
24        "movs %%r1, #0 \n\t"
25        "msr BASEPRI, %%r1 \n\t"
26
27        /* branch to _thread_entry(_main, 0, 0, 0) */
28        "mov %%r0, %1 \n\t"
29        "bx %2 \t\n"
30
31        /* never gets here */
32
33        :
34        : "r"(start_of_main_stack),
35          "r"(_main), "r"(_thread_entry),
36          "r"(main_thread)
37
38        : "r0", "r1", "sp"
39    );
40
41    CODE_UNREACHABLE;
42}

第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：

1 FUNC_NORETURN void _thread_entry(k_thread_entry_t entry,
2                  void *p1, void *p2, void *p3)
3 {
4     entry(p1, p2, p3);
5 
6     k_thread_abort(k_current_get());
7 
8     /*
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     */
12
13    CODE_UNREACHABLE;
14}

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

1  static void bg_thread_main(void *unused1, void *unused2, void *unused3)
2  {
3      ARG_UNUSED(unused1);
4      ARG_UNUSED(unused2);
5      ARG_UNUSED(unused3);
6  
7      _sys_device_do_config_level(_SYS_INIT_LEVEL_POST_KERNEL);
8  
9      if (boot_delay > 0) {
10         printk("***** delaying boot " STRINGIFY(CONFIG_BOOT_DELAY)
11                "ms (per build configuration) *****\n");
12         k_busy_wait(CONFIG_BOOT_DELAY * USEC_PER_MSEC);
13     }
14     PRINT_BOOT_BANNER();
15 
16     /* Final init level before app starts */
17     _sys_device_do_config_level(_SYS_INIT_LEVEL_APPLICATION);
18 
19     _init_static_threads();
20 
21     extern void main(void);
22 
23     main();
24 
25     /* Terminate thread normally since it has no more work to do */
26     _main_thread->base.user_options &= ~K_ESSENTIAL;
27 }

第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：

1 void _init_static_threads(void)
2 {
3     unsigned int  key;
4 
5     _FOREACH_STATIC_THREAD(thread_data) {
6         _setup_new_thread(
7             thread_data->init_thread,
8             thread_data->init_stack,
9             thread_data->init_stack_size,
10            thread_data->init_entry,
11            thread_data->init_p1,
12            thread_data->init_p2,
13            thread_data->init_p3,
14            thread_data->init_prio,
15            thread_data->init_options);
16
17        thread_data->init_thread->init_data = thread_data;
18    }
19
20    _sched_lock();
21
22    /*
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     */
31    key = irq_lock();
32    _FOREACH_STATIC_THREAD(thread_data) {
33        if (thread_data->init_delay != K_FOREVER) {
34            schedule_new_thread(thread_data->init_thread,
35                        thread_data->init_delay);
36        }
37    }
38    irq_unlock(key);
39    k_sched_unlock();
40}

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

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

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

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