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);
}