Zephys OS nano 内核篇：信号量 semaphore

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

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

信号量是 Zephyr OS 提供的用于不同线程间同步的机制。目前，Zephyr OS 只提供了信号量这一种同步机制。

信号量的类型定义

信号量的初始化

获取信号

_sem_take

nano_task_sem_take

释放(发送)信号

_sem_give_non_preemptible

nano_task_sem_give

信号量的类型定义

struct nano_sem {
struct _nano_queue wait_q;
int nsig;
#ifdef CONFIG_MICROKERNEL
struct _nano_queue task_q;          /* waiting tasks */
#endif
#ifdef CONFIG_DEBUG_TRACING_KERNEL_OBJECTS
struct nano_sem *__next;
#endif
};

不考虑 microkernel 的 task_q 和用于调试的 __next，信号量包含两个成员：

- nsig：信号量的值，即信号量的信号。当该值为 0，表示没有有效信号；当该值大于 0，表示有信号可以获取。

- wait_q：该信号量维护的等待队列。当一个线程试图获取无效的信号量(即信号量的值 nsig 为零)时，它可能会加入到这个等待队列中，然后陷入阻塞状态。

信号量的初始化

void nano_sem_init(struct nano_sem *sem)
{
sem->nsig = 0;
_nano_wait_q_init(&sem->wait_q);
SYS_TRACING_OBJ_INIT(nano_sem, sem); // 用于调试
_TASK_PENDQ_INIT(&sem->task_q);      // microkernel 才使用的
}

初始化信号量结构体中各成员：

- 将信号量的值初始化为 0。

- 初始化信号量的等待队列。

获取信号

int nano_sem_take(struct nano_sem *sem, int32_t timeout)
{
static int (*func[3])(struct nano_sem *, int32_t) = {
nano_isr_sem_take,
nano_fiber_sem_take,
nano_task_sem_take
};

return func[sys_execution_context_type_get()](sem, timeout);
}

先看看函数的入参：

- sem：希望获取信号的信号量。

- timeout：获取信号的超时等待时间，以滴答为单位。函数内部会根据该变量的值来做相应的处理。

再看看函数的返回值：

- 1 - 表示获取信号成功

- 0 - 表示获取信号失败

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

_sem_take

int _sem_take(struct nano_sem *sem, int32_t timeout_in_ticks)
{
unsigned int key = irq_lock();

if (likely(sem->nsig > 0)) {
// nsig > 0,说明可以获取信号
// 然后将信号量的值 nsig 递减
// 然后返回 1,表示获取信号成功
sem->nsig--;
irq_unlock(key);
return 1;
}

// 代码走到这里，说明当前没有有效的信号
if (timeout_in_ticks != TICKS_NONE) {
// 将当前线程加入内核的超时链表中，并绑定该超时节点的等待队列为
// 当前信号量所维护的等待队列
_NANO_TIMEOUT_ADD(&sem->wait_q, timeout_in_ticks);
// 将当前线程加入到该信号量维护的等待队列
_nano_wait_q_put(&sem->wait_q);
// return _Swap(key);
/* 原文是 return _Swap(key)，但是为了分析说明，我们将其拆分为下面两句话 */
int value = _Swap(key);
// 执行完 _Swap() 函数后，将会切换到其它上下文。如果该函数返回了，有两种可能：
// 1. 有线程向该信号量中添加了限号，唤醒了本线程，且在唤醒前设置了本线程的返回值，
//    具体信息可参考函数 _sem_give_non_preemptible
// 2. 由于等待超时，超时服务唤醒了本线程，本线程的返回值没有被设置，返回默认值 0
reutrn value;
}

//　代码走到这里，说明获取信号失败，且立即返回
irq_unlock(key);
return 0;
}

likely 是编译器内嵌的关键字，编译器会根据这个关键字对代码进行相应的优化，阅读代码时完全可以忽略。

当线程尝试从信号量中获取信号时，有两种可能：

- 信号量中有有效信号：即 nsig 的值大于 0，将 nsig 递减，获取信号成功。

- 信号量中没有有效信号：即 nsig 的值等于 0，无法获取信号，此时会根据入参 timeout_in_ticks 的值来做对应的处理：

- 等于 TICKS_NONE，表示当信号失败时，不等待，立即返回

- 不等于 TICKS_NONE，表示获取该信号的线程将陷入阻塞状态。在它陷入阻塞后，有两种可能

- 在 timeout_in_ticks 期间内，有另外一个线程向该信号量中添加了一个信号，等待线程将被添加信号的线程唤醒，获取信号成功。

- 在 timeout_in_ticks 期间内，没有线程向该信号量中添加值，那么等待将超时，定时器会将该线程唤醒，获取信号失败。

nano_task_sem_take

int nano_task_sem_take(struct nano_sem *sem, int32_t timeout_in_ticks)
{
int64_t cur_ticks;
int64_t limit = 0x7fffffffffffffffll; // 为什么这样初始化，不解
unsigned int key;

key = irq_lock();
// 获取当前的系统滴答数
cur_ticks = _NANO_TIMEOUT_TICK_GET();
if (timeout_in_ticks != TICKS_UNLIMITED) {
// 计算等待时间到期后的滴答数
limit = cur_ticks + timeout_in_ticks;
}

do {
if (likely(sem->nsig > 0)) {
// nsig > 0,说明可以获取信号
// 然后将信号量的值 nsig 递减
// 然后返回 1,表示获取信号成功
sem->nsig--;
irq_unlock(key);
return 1;
}

if (timeout_in_ticks != TICKS_NONE) {
// 让 task 等待，具体请见后面的分析
_NANO_OBJECT_WAIT(&sem->task_q, &sem->nsig,
timeout_in_ticks, key);

// 获取并更新当前的滴答数，用作循环的判断条件，判断是否跳出循环
cur_ticks = _NANO_TIMEOUT_TICK_GET();
_NANO_TIMEOUT_UPDATE(timeout_in_ticks,
limit, cur_ticks);
}
// 如果　timeout_in_ticks 等于 TICKS_NONE，那么 cur_ticks 等于 limit
// 循环判断的条件将失败，跳出循环，本函数立即返回，获取信号失败
} while (cur_ticks < limit);

irq_unlock(key);
return 0;
}

_NANO_OBJECT_WAIT() 是一个宏，对于 nanokernel，它的原型如下：

#define _NANO_OBJECT_WAIT(queue, data, timeout, key)     \
do {                                             \
_NANO_TIMEOUT_SET_TASK_TIMEOUT(timeout); \
nano_cpu_atomic_idle(key);               \
key = irq_lock();                        \
} while (0)

_NANO_TIMEOUT_SET_TASK_TIMEOUT()是设置内核大总管 _nanokernel 中 task_timeout 的值,目前还没发现这个有什么用。

nano_cpu_atomic_idle() 是用汇编实现的一个函数，它将使 CPU 进入睡眠状态，并在接收到中断后被唤醒。其原型如下：

SECTION_FUNC(TEXT, nano_cpu_atomic_idle)
// 本函数使用了两个通用寄存器,r0 和 r1。
// r0：调用者传递进来的中断的 mask
// r1：用于设置 BASEPRI 的值

//　异或操作，将 r1 与 r1，进行异或操作，将结果保存到 r1 中，所以 r1 里面的值为 0
// .n 用于告诉编译器使用 16 位的指令进行汇编
eors.n r1, r1

// 锁定 PRIMASK, 此时系统不会处理中断
cpsid i

// 将 0 写入寄存器 BASEPRI，此时系统将能够接收**所有**中断
msr BASEPRI, r1

// 此时的状态：能接收中断，但是先不处理中断

// wfe，Wait For Event，等待事件的到来。执行这个指令后，CPU 将进入睡眠状态，进入低功
// 耗模式。更具体地说，执行 wfe　指令后，CPU core 将会发送一个信号，pmu 收到这个信号后，
// 将关闭 core 的 clock，甚至进入 retention 模式(降低电压，但是保存寄存器和cache 的值)。
wfe

// 此时 cpu 陷入睡眠了，不再取指执行。

// 当有外部中断到来时，将会唤醒 CPU,然后继续执行下面的指令.

// 恢复睡眠之前的中断优先级
msr BASEPRI, r0

// 允许执行之前检测到的中断信号的 ISR
cpsie i

// 可能会在这里执行 ISR.

// 返回调用函数
bx lr

释放(发送)信号

void nano_sem_give(struct nano_sem *sem)
{
static void (*func[3])(struct nano_sem *sem) = {
nano_isr_sem_give,
nano_fiber_sem_give,
nano_task_sem_give
};

func[sys_execution_context_type_get()](sem);
}

根据当前上下文的类型，调用对应的添加信号量的函数。其中，nano_isr_sem_give() 和 nano_fiber_sem_give() 是函数 _sem_give_non_preemptible()的别名。

我之所以将这个函数叫做释放信号或发送信号，是因为信号量的两种应用场景：

- 当一个线程对某个临界资源访问前，它先要获取信号，访问完后，还需要释放信号

- 当一个线程获取信号时，被陷入阻塞状态。此时如果有另一个线程释放了信号，阻塞的线程将被唤醒。我们可以将其利皆为该线程对阻塞的线程发送了一个唤醒信号。

_sem_give_non_preemptible

void _sem_give_non_preemptible(struct nano_sem *sem)
{
struct tcs *tcs;
unsigned int imask;

imask = irq_lock();
// 取出信号量的等待队列的队首数据，判断有没有线程在等待信号
tcs = _nano_wait_q_remove(&sem->wait_q);
if (!tcs) {
// 如果没有线程在等待信号，直接将信号量的值递增
// 此外，_nano_wait_q_remove 内部会将队首的线程加入到就绪队列
// 即该线程的状态由阻塞态变为了就绪态
sem->nsig++;
_NANO_UNPEND_TASKS(&sem->task_q);
} else {
//　如果有线程在等待信号，将该线程从超时队列中删除
_nano_timeout_abort(tcs);
// 此时不设置信号量的值，直接设置等待线程的返回值为 1
set_sem_available(tcs);
}

irq_unlock(imask);
}

前面在从信号量中获取信号时，如果线程获取信号失败，做了两件事儿：

- 将线程阻塞(加入等待队列中)

- 将线程加入超时链表中

对应的，在往信号量中添加信号时，如果判断出有线程处于等待状态，也做了两件事儿：

- 将阻塞的线程添加到就绪链表中

- 将线程从超时链表中删除

nano_task_sem_give

void nano_task_sem_give(struct nano_sem *sem)
{
struct tcs *tcs;
unsigned int imask;

imask = irq_lock();
// 取出信号量的等待队列的队首数据，判断有没有线程在等待信号
tcs = _nano_wait_q_remove(&sem->wait_q);
if (tcs) {
// 如果有线程在等待信号，将该线程从超时队列中删除
// 此外，_nano_wait_q_remove 内部会将队首的线程加入到就绪队列
_nano_timeout_abort(tcs);
// 此时不设置信号量的值，直接设置等待线程的返回值为 1
set_sem_available(tcs);
由于 wait_q 中保存的线程是 fiber，而当前的线程是 task，所以让出 cpu，让该 fiber 先运行。
_Swap(imask);
return;
}

// 代码走到这里，说明之前没有线程在等待信号
// 将信号量的值递增
sem->nsig++;
_TASK_NANO_UNPEND_TASKS(&sem->task_q);

irq_unlock(imask);
}