Zephyr 内核源码分析¶

/* 复位向量入口 */
SECTION_FUNC(TEXT, __start)
    /* 设置主栈指针 (MSP) */
    ldr r0, =_interrupt_stack
    ldr r1, [r0]
    msr MSP, r1

    /* 复制数据段从 Flash 到 RAM */
    ldr r0, =__data_rom_start
    ldr r1, =__data_ram_start
    ldr r2, =__data_ram_end

data_copy_loop:
    cmp r1, r2
    bge data_copy_done
    ldr r3, [r0], #4
    str r3, [r1], #4
    b data_copy_loop

data_copy_done:
    /* 清零 BSS 段 */
    ldr r0, =__bss_start
    ldr r1, =__bss_end
    movs r2, #0

bss_zero_loop:
    cmp r0, r1
    bge bss_zero_done
    str r2, [r0], #4
    b bss_zero_loop

bss_zero_done:
    /* 跳转到 C 代码入口 */
    bl z_cstart

/**
 * @brief Zephyr 内核启动入口
 */
FUNC_NORETURN void z_cstart(void)
{
    /* 架构特定的早期初始化 */
    arch_kernel_init();

    /* PRE_KERNEL_1: 最早期的初始化 */
    z_sys_init_run_level(SYS_INIT_LEVEL_PRE_KERNEL_1);

    /* PRE_KERNEL_2: 内核对象初始化 */
    z_sys_init_run_level(SYS_INIT_LEVEL_PRE_KERNEL_2);

    /* 初始化内核对象 */
    z_kernel_init();

    /* POST_KERNEL: 设备驱动初始化 */
    z_sys_init_run_level(SYS_INIT_LEVEL_POST_KERNEL);

    /* APPLICATION: 应用级初始化 */
    z_sys_init_run_level(SYS_INIT_LEVEL_APPLICATION);

    /* 切换到主线程 */
    z_switch_to_main_thread();

    /* 永不返回 */
    CODE_UNREACHABLE;
}

/* 在 PRE_KERNEL_1 阶段，优先级 10 初始化 */
static int my_early_init(void)
{
    /* 早期初始化代码 */
    return 0;
}
SYS_INIT(my_early_init, PRE_KERNEL_1, 10);

/* 在 POST_KERNEL 阶段，优先级 50 初始化设备 */
static int my_device_init(void)
{
    /* 设备初始化代码 */
    return 0;
}
SYS_INIT(my_device_init, POST_KERNEL, 50);

/* 设备定义示例 */
DEVICE_DT_DEFINE(
    DT_NODELABEL(uart0),        /* 设备树节点 */
    uart_init,                   /* 初始化函数 */
    NULL,                        /* 电源管理函数 */
    &uart0_data,                 /* 设备数据 */
    &uart0_config,               /* 设备配置 */
    POST_KERNEL,                 /* 初始化阶段 */
    CONFIG_SERIAL_INIT_PRIORITY, /* 优先级 */
    &uart_api                    /* 设备 API */
);

struct _kernel {
    /* 当前运行的线程 */
    struct k_thread *current;

    /* 就绪队列 */
    struct _ready_q ready_q;

    /* 空闲线程 */
    struct k_thread *idle_thread;

    /* CPU 空闲标志 */
    uint8_t idle;

    /* 时间片计数器 */
    int32_t slice_ticks;

    /* 系统时钟 */
    uint64_t ticks;
};

/* 全局内核对象 */
extern struct _kernel _kernel;

struct k_thread {
    /* 架构相关的上下文 */
    struct _callee_saved callee_saved;

    /* 线程栈信息 */
    char *stack_info;

    /* 基础优先级 */
    int8_t base_prio;

    /* 当前优先级（可能被优先级继承修改）*/
    int8_t prio;

    /* 线程状态标志 */
    uint32_t thread_state;

    /* 等待队列节点 */
    struct _wait_q_t wait_q;

    /* 超时对象 */
    struct _timeout timeout;

    /* 线程名称 */
    const char *name;

    /* 线程入口函数 */
    k_thread_entry_t entry;
    void *p1, *p2, *p3;
};

struct _ready_q {
    /* 优先级位图（快速查找最高优先级）*/
    uint32_t prio_bmap[2];

    /* 每个优先级的线程队列 */
    sys_dlist_t q[CONFIG_NUM_PREEMPT_PRIORITIES];
};

/* 将线程加入就绪队列 */
void z_ready_thread(struct k_thread *thread)
{
    int prio = thread->prio;

    /* 将线程加入对应优先级的队列 */
    sys_dlist_append(&_kernel.ready_q.q[prio], &thread->base.qnode);

    /* 设置优先级位图 */
    _kernel.ready_q.prio_bmap[prio / 32] |= (1 << (prio % 32));
}

/* 从就绪队列移除线程 */
void z_remove_thread_from_ready_q(struct k_thread *thread)
{
    int prio = thread->prio;

    /* 从队列中移除 */
    sys_dlist_remove(&thread->base.qnode);

    /* 如果该优先级队列为空，清除位图 */
    if (sys_dlist_is_empty(&_kernel.ready_q.q[prio])) {
        _kernel.ready_q.prio_bmap[prio / 32] &= ~(1 << (prio % 32));
    }
}

/* 查找最高优先级的就绪线程 */
struct k_thread *z_get_next_ready_thread(void)
{
    /* 使用 CLZ (Count Leading Zeros) 指令快速查找 */
    int prio = find_first_set_bit(_kernel.ready_q.prio_bmap);

    if (prio < 0) {
        /* 没有就绪线程，返回空闲线程 */
        return _kernel.idle_thread;
    }

    /* 返回该优先级队列的第一个线程 */
    sys_dnode_t *node = sys_dlist_peek_head(&_kernel.ready_q.q[prio]);
    return CONTAINER_OF(node, struct k_thread, base.qnode);
}

/**
 * @brief 核心调度函数
 * 
 * 选择下一个要运行的线程，如果需要则触发上下文切换
 */
void z_reschedule(void)
{
    struct k_thread *current = _kernel.current;
    struct k_thread *next;

    /* 如果调度器被锁定，不进行调度 */
    if (_kernel.sched_lock > 0) {
        return;
    }

    /* 查找最高优先级的就绪线程 */
    next = z_get_next_ready_thread();

    /* 如果下一个线程就是当前线程，无需切换 */
    if (next == current) {
        return;
    }

    /* 如果启用了时间片轮转 */
    #ifdef CONFIG_TIMESLICING
    if (next->prio == current->prio && 
        current->base.slice_ticks > 0) {
        /* 同优先级且当前线程还有时间片，不切换 */
        return;
    }
    #endif

    /* 执行上下文切换 */
    z_swap(current, next);
}

/**
 * @brief 触发上下文切换
 * 
 * 通过触发 PendSV 异常实现上下文切换
 */
void arch_swap(unsigned int key)
{
    /* 触发 PendSV 异常 */
    SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;

    /* 等待 PendSV 执行 */
    __DSB();
    __ISB();
}

/**
 * @brief PendSV 异常处理函数（汇编实现）
 * 
 * 文件：arch/arm/core/cortex_m/swap_helper.S
 */
__pendsv:
    /* 保存当前线程上下文 */
    mrs r0, PSP                    /* 获取进程栈指针 */

    #ifdef CONFIG_FPU
    vstmdb r0!, {s16-s31}          /* 保存 FPU 寄存器 */
    #endif

    stmdb r0!, {r4-r11, lr}        /* 保存通用寄存器 */

    /* 保存栈指针到线程控制块 */
    ldr r1, =_kernel
    ldr r2, [r1, #_kernel_offset_to_current]
    str r0, [r2, #_thread_offset_to_sp]

    /* 获取下一个线程 */
    bl z_get_next_switch_handle

    /* 恢复下一个线程上下文 */
    ldr r0, [r0, #_thread_offset_to_sp]

    ldmia r0!, {r4-r11, lr}        /* 恢复通用寄存器 */

    #ifdef CONFIG_FPU
    vldmia r0!, {s16-s31}          /* 恢复 FPU 寄存器 */
    #endif

    msr PSP, r0                    /* 设置进程栈指针 */

    /* 返回到新线程 */
    bx lr

/* 时间片配置 */
#define CONFIG_TIMESLICE_SIZE 10    /* 时间片大小（毫秒）*/
#define CONFIG_TIMESLICE_PRIORITY 0 /* 时间片适用的最低优先级 */

/**
 * @brief 时间片定时器回调
 * 
 * 每个时钟滴答调用，减少当前线程的时间片
 */
void z_time_slice(void)
{
    struct k_thread *curr = _kernel.current;

    /* 检查是否启用时间片 */
    if (!IS_ENABLED(CONFIG_TIMESLICING)) {
        return;
    }

    /* 检查线程优先级是否适用时间片 */
    if (curr->prio > CONFIG_TIMESLICE_PRIORITY) {
        return;
    }

    /* 减少时间片计数 */
    if (curr->base.slice_ticks > 0) {
        curr->base.slice_ticks--;
    }

    /* 时间片用完，触发调度 */
    if (curr->base.slice_ticks == 0) {
        /* 重置时间片 */
        curr->base.slice_ticks = CONFIG_TIMESLICE_SIZE;

        /* 将当前线程移到队列尾部 */
        z_remove_thread_from_ready_q(curr);
        z_ready_thread(curr);

        /* 触发调度 */
        z_reschedule();
    }
}

/* 1. 用户调用 k_sleep() */
int k_sleep(k_timeout_t timeout)
{
    /* 文件：kernel/sched.c */
    return z_impl_k_sleep(timeout);
}

/* 2. 实现函数 */
int z_impl_k_sleep(k_timeout_t timeout)
{
    /* 获取当前线程 */
    struct k_thread *thread = _current;

    /* 添加超时 */
    z_add_timeout(&thread->base.timeout, timeout);

    /* 将线程从就绪队列移除 */
    z_remove_thread_from_ready_q(thread);

    /* 设置线程状态为等待 */
    thread->base.thread_state |= _THREAD_SLEEPING;

    /* 3. 触发调度 */
    z_reschedule();

    return 0;
}

/* 4. 调度器选择下一个线程 */
void z_reschedule(void)
{
    /* 查找最高优先级就绪线程 */
    struct k_thread *next = z_get_next_ready_thread();

    /* 5. 执行上下文切换 */
    if (next != _current) {
        arch_swap(0);
    }
}

/* 6. 超时到期后，定时器回调唤醒线程 */
void z_timeout_handle(struct _timeout *timeout)
{
    struct k_thread *thread = CONTAINER_OF(timeout, struct k_thread, base.timeout);

    /* 清除睡眠状态 */
    thread->base.thread_state &= ~_THREAD_SLEEPING;

    /* 将线程加回就绪队列 */
    z_ready_thread(thread);

    /* 触发调度（可能抢占当前线程）*/
    z_reschedule();
}

/**
 * @brief 堆块头部
 */
struct heap_block {
    /* 块大小（包含头部）*/
    size_t size;

    /* 空闲列表链接 */
    struct heap_block *next;
    struct heap_block *prev;

    /* 块状态标志 */
    uint32_t flags;
};

/**
 * @brief 堆结构
 */
struct sys_heap {
    /* 堆内存起始地址 */
    void *heap;

    /* 堆大小 */
    size_t len;

    /* 空闲块列表（按大小分级）*/
    struct heap_block *free_lists[NUM_SIZE_CLASSES];

    /* 统计信息 */
    size_t allocated_bytes;
    size_t max_allocated_bytes;
};

/**
 * @brief 从堆分配内存
 */
void *k_malloc(size_t size)
{
    struct sys_heap *heap = &_system_heap;
    struct heap_block *block;

    /* 对齐大小 */
    size = ROUND_UP(size + sizeof(struct heap_block), HEAP_ALIGN);

    /* 查找合适的空闲块 */
    block = find_free_block(heap, size);

    if (block == NULL) {
        /* 没有足够的内存 */
        return NULL;
    }

    /* 如果块太大，分割它 */
    if (block->size >= size + MIN_BLOCK_SIZE) {
        split_block(block, size);
    }

    /* 从空闲列表移除 */
    remove_from_free_list(heap, block);

    /* 标记为已分配 */
    block->flags |= BLOCK_ALLOCATED;

    /* 更新统计 */
    heap->allocated_bytes += block->size;
    if (heap->allocated_bytes > heap->max_allocated_bytes) {
        heap->max_allocated_bytes = heap->allocated_bytes;
    }

    /* 返回用户数据区域 */
    return (void *)((char *)block + sizeof(struct heap_block));
}

/**
 * @brief 释放内存
 */
void k_free(void *ptr)
{
    struct sys_heap *heap = &_system_heap;
    struct heap_block *block;

    if (ptr == NULL) {
        return;
    }

    /* 获取块头部 */
    block = (struct heap_block *)((char *)ptr - sizeof(struct heap_block));

    /* 检查块是否已分配 */
    __ASSERT(block->flags & BLOCK_ALLOCATED, "Double free detected");

    /* 清除分配标志 */
    block->flags &= ~BLOCK_ALLOCATED;

    /* 更新统计 */
    heap->allocated_bytes -= block->size;

    /* 尝试与相邻空闲块合并 */
    block = coalesce_blocks(heap, block);

    /* 加入空闲列表 */
    add_to_free_list(heap, block);
}

/**
 * @brief 合并相邻空闲块
 */
static struct heap_block *coalesce_blocks(struct sys_heap *heap, 
                                          struct heap_block *block)
{
    struct heap_block *next = get_next_block(block);
    struct heap_block *prev = get_prev_block(block);

    /* 与后面的块合并 */
    if (next && !(next->flags & BLOCK_ALLOCATED)) {
        remove_from_free_list(heap, next);
        block->size += next->size;
    }

    /* 与前面的块合并 */
    if (prev && !(prev->flags & BLOCK_ALLOCATED)) {
        remove_from_free_list(heap, prev);
        prev->size += block->size;
        block = prev;
    }

    return block;
}

/**
 * @brief 内存池结构
 */
struct k_mem_pool {
    /* 块大小 */
    size_t block_size;

    /* 块数量 */
    size_t num_blocks;

    /* 空闲块列表 */
    void *free_list;

    /* 内存池缓冲区 */
    char *buffer;

    /* 锁 */
    struct k_spinlock lock;
};

/**
 * @brief 从内存池分配块
 */
int k_mem_pool_alloc(struct k_mem_pool *pool, void **block)
{
    k_spinlock_key_t key;
    void *ptr;

    key = k_spin_lock(&pool->lock);

    /* 从空闲列表获取块 */
    ptr = pool->free_list;

    if (ptr == NULL) {
        k_spin_unlock(&pool->lock, key);
        return -ENOMEM;
    }

    /* 更新空闲列表 */
    pool->free_list = *(void **)ptr;

    k_spin_unlock(&pool->lock, key);

    *block = ptr;
    return 0;
}

/**
 * @brief 释放块回内存池
 */
void k_mem_pool_free(struct k_mem_pool *pool, void *block)
{
    k_spinlock_key_t key;

    key = k_spin_lock(&pool->lock);

    /* 将块加回空闲列表 */
    *(void **)block = pool->free_list;
    pool->free_list = block;

    k_spin_unlock(&pool->lock, key);
}

/**
 * @brief 定义线程栈
 */
#define K_THREAD_STACK_DEFINE(sym, size) \
    struct z_thread_stack_element sym[K_THREAD_STACK_LEN(size)] \
        __aligned(ARCH_STACK_PTR_ALIGN)

/**
 * @brief 线程栈结构
 */
struct z_thread_stack_element {
    char data;
} __aligned(ARCH_STACK_PTR_ALIGN);

/**
 * @brief 初始化线程栈
 */
void z_setup_new_thread(struct k_thread *thread,
                        k_thread_stack_t *stack,
                        size_t stack_size,
                        k_thread_entry_t entry,
                        void *p1, void *p2, void *p3)
{
    /* 栈顶地址 */
    char *stack_top = (char *)stack + stack_size;

    /* 栈底保护字（用于检测栈溢出）*/
    #ifdef CONFIG_THREAD_STACK_INFO
    thread->stack_info.start = (uintptr_t)stack;
    thread->stack_info.size = stack_size;
    *(uint32_t *)stack = STACK_SENTINEL;
    #endif

    /* 初始化栈帧 */
    thread->callee_saved.psp = (uint32_t)arch_new_thread(
        stack_top, entry, p1, p2, p3);
}

/**
 * @brief 检查栈溢出
 */
void z_check_stack_sentinel(struct k_thread *thread)
{
    #ifdef CONFIG_THREAD_STACK_INFO
    uint32_t *sentinel = (uint32_t *)thread->stack_info.start;

    if (*sentinel != STACK_SENTINEL) {
        /* 栈溢出！*/
        k_panic();
    }
    #endif
}

/**
 * @brief 获取栈使用情况
 */
size_t z_stack_space_get(struct k_thread *thread)
{
    char *stack_start = (char *)thread->stack_info.start;
    char *stack_end = stack_start + thread->stack_info.size;
    char *sp = (char *)thread->callee_saved.psp;

    /* 计算已使用的栈空间 */
    return stack_end - sp;
}

/**
 * @brief 配置 MPU 区域
 */
void arm_core_mpu_configure_thread(struct k_thread *thread)
{
    /* 配置线程栈区域为读写，禁止执行 */
    arm_core_mpu_region_config(
        MPU_REGION_THREAD_STACK,
        (uint32_t)thread->stack_info.start,
        thread->stack_info.size,
        ARM_MPU_RASR_XN_Msk |           /* 禁止执行 */
        ARM_MPU_RASR_AP_RW_RW |         /* 读写权限 */
        ARM_MPU_RASR_ENABLE_Msk         /* 启用区域 */
    );

    /* 配置用户数据区域 */
    if (thread->base.user_options & K_USER) {
        arm_core_mpu_region_config(
            MPU_REGION_USER_DATA,
            (uint32_t)thread->userspace_local_data,
            sizeof(struct _k_thread_userspace_local_data),
            ARM_MPU_RASR_AP_RW_RW |     /* 用户读写 */
            ARM_MPU_RASR_ENABLE_Msk
        );
    }
}

/**
 * @brief MPU 故障处理
 */
void z_arm_mpu_fault(void)
{
    uint32_t mmfsr = SCB->CFSR & SCB_CFSR_MEMFAULTSR_Msk;
    uint32_t mmfar = SCB->MMFAR;

    if (mmfsr & SCB_CFSR_DACCVIOL_Msk) {
        /* 数据访问违规 */
        printk("MPU: Data access violation at 0x%08x\n", mmfar);
    }

    if (mmfsr & SCB_CFSR_IACCVIOL_Msk) {
        /* 指令访问违规 */
        printk("MPU: Instruction access violation\n");
    }

    /* 终止违规线程 */
    k_thread_abort(_current);
}

/* K_THREAD_DEFINE 宏展开 */
K_THREAD_DEFINE(my_thread, 1024, my_entry, NULL, NULL, NULL, 5, 0, 0);

/* 展开后 */
static struct k_thread my_thread_data;
static K_THREAD_STACK_DEFINE(my_thread_stack, 1024);

static void my_thread_init(void) {
    k_thread_create(&my_thread_data, my_thread_stack, 1024,
                    my_entry, NULL, NULL, NULL, 5, 0, 0);
}
SYS_INIT(my_thread_init, APPLICATION, 0);

struct k_thread {
    /* === 架构相关部分 === */
    struct _callee_saved {
        uint32_t psp;      /* 进程栈指针 */
        uint32_t r4;       /* 通用寄存器 r4-r11 */
        uint32_t r5;
        uint32_t r6;
        uint32_t r7;
        uint32_t r8;
        uint32_t r9;
        uint32_t r10;
        uint32_t r11;
        uint32_t lr;       /* 链接寄存器 */
    } callee_saved;

    /* === 栈信息 === */
    struct _thread_stack_info {
        uintptr_t start;   /* 栈起始地址 */
        size_t size;       /* 栈大小 */
    } stack_info;

    /* === 调度信息 === */
    int8_t base_prio;      /* 基础优先级 */
    int8_t prio;           /* 当前优先级（可能被继承修改）*/
    uint32_t thread_state; /* 线程状态标志 */

    /* === 等待队列 === */
    struct _wait_q_t {
        sys_dlist_t waitq; /* 等待队列链表 */
    } wait_q;

    /* === 超时管理 === */
    struct _timeout {
        sys_dnode_t node;  /* 超时队列节点 */
        k_timeout_t dticks;/* 剩余时间 */
        void (*fn)(struct _timeout *); /* 超时回调 */
    } timeout;

    /* === 线程标识 === */
    const char *name;      /* 线程名称 */

    /* === 入口函数 === */
    k_thread_entry_t entry;/* 线程入口函数 */
    void *p1, *p2, *p3;    /* 入口参数 */

    /* === 时间片 === */
    int32_t slice_ticks;   /* 剩余时间片 */

    /* === 用户空间（可选）=== */
    #ifdef CONFIG_USERSPACE
    struct _k_thread_userspace_local_data *userspace_local_data;
    #endif
};

/**
 * @brief 设备结构
 */
struct device {
    /* 设备名称 */
    const char *name;

    /* 设备配置（只读）*/
    const void *config;

    /* 设备 API（函数指针表）*/
    const void *api;

    /* 设备状态（运行时数据）*/
    struct device_state *state;

    /* 设备数据（驱动私有数据）*/
    void *data;

    /* 设备依赖 */
    const struct device *deps[];
};

/**
 * @brief 设备状态
 */
struct device_state {
    /* 初始化状态 */
    uint8_t initialized : 1;

    /* 电源管理状态 */
    uint8_t pm_state : 2;

    /* 锁 */
    struct k_mutex lock;
};

/**
 * @brief UART 设备 API
 */
struct uart_driver_api {
    int (*poll_in)(const struct device *dev, unsigned char *c);
    void (*poll_out)(const struct device *dev, unsigned char c);
    int (*configure)(const struct device *dev, const struct uart_config *cfg);
    int (*irq_tx_enable)(const struct device *dev);
    int (*irq_tx_disable)(const struct device *dev);
    int (*irq_rx_enable)(const struct device *dev);
    int (*irq_rx_disable)(const struct device *dev);
};

/* 使用设备 API */
const struct device *uart = DEVICE_DT_GET(DT_NODELABEL(uart0));
const struct uart_driver_api *api = uart->api;

/* 调用驱动函数 */
api->poll_out(uart, 'A');

struct k_mutex {
    /* 等待队列 */
    _wait_q_t wait_q;

    /* 当前持有者 */
    struct k_thread *owner;

    /* 锁定计数（支持递归锁）*/
    uint32_t lock_count;

    /* 原始优先级（用于优先级继承）*/
    int original_prio;
};

struct k_sem {
    /* 等待队列 */
    _wait_q_t wait_q;

    /* 当前计数 */
    uint32_t count;

    /* 最大计数 */
    uint32_t limit;
};

struct k_msgq {
    /* 等待队列（发送者和接收者）*/
    _wait_q_t wait_q;

    /* 消息大小 */
    size_t msg_size;

    /* 最大消息数 */
    uint32_t max_msgs;

    /* 已使用消息数 */
    uint32_t used_msgs;

    /* 读写索引 */
    uint32_t read_index;
    uint32_t write_index;

    /* 消息缓冲区 */
    char *buffer;

    /* 锁 */
    struct k_spinlock lock;
};