Zephys OS nano 内核篇：栈 stack

Zephyr OS 所有的学习笔记已托管到 Github，CSDN 博客里的内容只是 Github 里内容的拷贝，因此链接会有错误，请谅解。

最新的学习笔记请移步 GitHub：https://github.com/tidyjiang8/zephyr-inside

• 栈的类型定义
• 栈的初始化
• 出栈操作
  
  • _stack_pop
  • nano_task_stack_pop
• 入栈操作
  
  • _stack_push_non_preemptible
  • nano_task_stack_push

栈是 nanokernel 提供的另一种用于在不同线程间传递数据的服务，它也是后进先出的，但是它与 lifo 的不同之处在于两点：

• 栈中的元素的大小是固定的，每个元素都是一个整型；lifo中的元素的数据的大小是不固定的
• 栈的内存空间是在栈的初始化时就固定了，里面保存的每个元素是实实在在的数据；lifo中保持的数据的内存空间是由向lifo中添加数据的线程分配的，所以lifo里面保存的是数据的指针。

栈的类型定义

struct nano_stack {
    nano_thread_id_t fiber;
    uint32_t *base;
    uint32_t *next;
#ifdef CONFIG_DEBUG_TRACING_KERNEL_OBJECTS
    struct nano_stack *__next;
#endif
};

不考虑用于调试的 __next，一共包含3个成员：

• fiber：一个栈允许一个线程在从栈中取数据时处于阻塞状态。fiber这个成员就用来保存这个阻塞的线程。
• base：指向栈底。
• next：指向栈中数据顶部的下一个地址，即栈空闲空间的底部，如下图所示。

栈结构体和栈在内存空间的存储情况如下图所示；

图：栈结构体与栈在内存空间的存储结构

栈的初始化

void nano_stack_init(struct nano_stack *stack, uint32_t *data)
{
    stack->next = stack->base = data;
    stack->fiber = (struct tcs *)0;
    SYS_TRACING_OBJ_INIT(nano_stack, stack);
}

初始化栈结构体中相关成员：将 base、next 指向栈底，将 fiber 指向 NULL。

出栈操作

int nano_stack_pop(struct nano_stack *stack, uint32_t *pData, int32_t timeout_in_ticks)
{
    static int (*func[3])(struct nano_stack *, uint32_t *, int32_t) = {
        nano_isr_stack_pop,
        nano_fiber_stack_pop,
        nano_task_stack_pop,
    };

    return func[sys_execution_context_type_get()](stack, pData, timeout_in_ticks);
}

先看看函数的入参：

• stack：待取数据的栈
• pData：用来保存从栈中取得的数据
• timeout_in_ticks：出栈的超时等待时间，以滴答为单位。函数内部会根据该变量的值来做相应的处理。

再看看函数的返回值：

• 1 - 表示出栈成功，即成功从栈中取得数据。
• 0 - 表示出栈失败，即没有从栈中取得数据。

nano_stack_pop会根据当前上下文的类型，调用对应的获取信号的函数。其中，nano_isr_stack_pop() 和 nano_fiber_stack_pop() 是函数 _stack_pop() 的别名。

_stack_pop

int _stack_pop(struct nano_stack *stack, uint32_t *pData, int32_t timeout_in_ticks)
{
    unsigned int imask;

    imask = irq_lock();

    if (likely(stack->next > stack->base)) {
        // 如果栈中有数据，则直接从栈中取出：
        // 将 next 指针后移，指向数据的顶部
        // 然后取出数据，放入 pData 指向的内存处
        // 然后返回 1，表示出栈操作成功
        stack->next--;
        *pData = *(stack->next);
        irq_unlock(imask);
        return 1;
    }

    if (timeout_in_ticks != TICKS_NONE) {
        // 如果栈中没有数据，将当前线程(即正在执行出栈操作的线程)
        // 用栈中的 fiber 成员保存起来
        // 然后进行上下文切换
        stack->fiber = _nanokernel.current;
        *pData = (uint32_t) _Swap(imask);
        // 指向完 _Swap() 函数后，将会切换到其它上下文
        // 如果代码能走到这里，说明有其它线程向该栈中压入了数据，并唤醒了本线程
        // 将数据存放到 pData 指向的内存中
        // 然后返回 1，表示出栈操作成功
        return 1;
    }

    // 如果代码走到这里，说明执行操作操作的线程不希望进行延时等待
    // 此时出栈操作失败，立即返回
    irq_unlock(imask);
    return 0;
}

当某线程尝试从栈中弹出数据时，有两种可能：

• 栈中有数据，直接弹出数据顶部的数据
• 栈中没有数据，此时会根据入参 timeout_in_ticks 的值来做对应的处理：
  
  • 等于 TICKS_NONE，表示不进行超时等待，立即返回
  • 不等于 TICKS_NONE，将其陷入阻状态，并等待其它需要入栈的线程唤醒本线程

与前面所学的信号量、fifo、lifo都不同的是：

• 栈中没有设置等待队列，只用了一个fiber成员，最多只能保存一个阻塞线程，因此当多个线程都尝试向一个空栈中弹出数据时，只有最后一个线程能被保存，其它的线程将被替换掉，永远也无法获取数据(而且最奇怪的是，这个线程好像也不处于就绪队列，将永远不会在被执行)。为什么要这样设计？可能与栈的具体应用有关系，目前还不清楚。
• 当从栈中弹出数据失败时，没有将线程放入超时链表中，因此传入的参数 timeout_in_ticks 只要不等于 TICKS_NONE，将一直陷入阻塞，直到有其它线程需要向栈中压入数据

nano_task_stack_pop

int nano_task_stack_pop(struct nano_stack *stack, uint32_t *pData, int32_t timeout_in_ticks)
{
    unsigned int imask;

    imask = irq_lock();

    while (1) {
        if (likely(stack->next > stack->base)) {
            // 如果栈中有数据，则直接从栈中取出：
            // 将 next 指针后移，指向数据的顶部
            // 然后取出数据，放入 pData 指向的内存处
            // 然后返回 1，表示出栈操作成功
            stack->next--;
            *pData = *(stack->next);
            irq_unlock(imask);
            return 1;
        }

        if (timeout_in_ticks == TICKS_NONE) {
            // 如果 timeout_in_ticks 等于 TICKS_NONE，跳出循环，立即返回
            break;
        }

        // nano_cpu_atomic_idle() 函数已在《Zephyr OS nano 内核篇：信号量》中详
        // 细分析过，它会让cpu进入睡眠模式，如果发生外部中断，cpu会被唤醒。
        nano_cpu_atomic_idle(imask);
        imask = irq_lock();
    }

    irq_unlock(imask);
    return 0;
}

入栈操作

void nano_stack_push(struct nano_stack *stack, uint32_t data)
{
    static void (*func[3])(struct nano_stack *, uint32_t) = {
        nano_isr_stack_push,
        nano_fiber_stack_push,
        nano_task_stack_push
    };

    func[sys_execution_context_type_get()](stack, data);
}

先看看函数的入参：

• stack：待压入数据的栈。
• data：待压如栈中的数据，其数据类型是无符号整型。

nano_stack_push会根据当前上下文的类型，调用对应的获取信号的函数。其中，nano_isr_stack_push() 和 nano_fiber_stack_push() 是函数 nano_stack_push() 的别名。

_stack_push_non_preemptible

void _stack_push_non_preemptible(struct nano_stack *stack, uint32_t data)
{
    struct tcs *tcs;
    unsigned int imask;

    imask = irq_lock();

    tcs = stack->fiber;
    if (tcs) {
        // 如果之前已有线程在等待从栈中取数据，直接设置将数据设置为该线程的返回值，
        // 然后将其从阻塞态变为就绪态，加入就绪链表
        stack->fiber = 0;
        fiberRtnValueSet(tcs, data);
        _nano_fiber_ready(tcs);
    } else {
        // 将数据压栈
        *(stack->next) = data;
        // next 指针上移
        stack->next++;
    }

    irq_unlock(imask);
}

注意，由于在入栈时没有检查栈是否已满，所以在使用时必须小心，否则栈溢出了，后果很严重。这算不算stack中的一个bug？

nano_task_stack_push

void nano_task_stack_push(struct nano_stack *stack, uint32_t data)
{
    struct tcs *tcs;
    unsigned int imask;

    imask = irq_lock();

    tcs = stack->fiber;
    if (tcs) {
        // 如果之前已有线程在等待从栈中取数据，直接设置将数据设置为该线程的返回值，
        // 然后将其从阻塞态变为就绪态，加入就绪链表
        stack->fiber = 0;
        fiberRtnValueSet(tcs, data);
        _nano_fiber_ready(tcs);
        // 由于当前上下文是task，而就绪链表中存在fiber，所以就绪上下文切换
        _Swap(imask);
        return;
    }

    // 代码走到这里，说明之前没有程序在等待从栈中取数据，直接将数据入栈
    *(stack->next) = data;
    stack->next++;

    irq_unlock(imask);
}