1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

MEMORY
{
FLASH : ORIGIN = 0x08000000, LENGTH = 64K
RAM : ORIGIN = 0x20000000, LENGTH = 20K
}
PROVIDE(_stext = ORIGIN(REGION_TEXT));
PROVIDE(_stack_start = ORIGIN(REGION_STACK) + LENGTH(REGION_STACK));
PROVIDE(_max_hart_id = 0);
PROVIDE(_hart_stack_size = 2K);
PROVIDE(_heap_size = 0);
PROVIDE(UserSoft = DefaultHandler);
PROVIDE(SupervisorSoft = DefaultHandler);
PROVIDE(MachineSoft = DefaultHandler);
PROVIDE(UserTimer = DefaultHandler);
PROVIDE(SupervisorTimer = DefaultHandler);
PROVIDE(MachineTimer = DefaultHandler);
PROVIDE(UserExternal = DefaultHandler);
PROVIDE(SupervisorExternal = DefaultHandler);
PROVIDE(MachineExternal = DefaultHandler);
PROVIDE(DefaultHandler = DefaultInterruptHandler);
PROVIDE(ExceptionHandler = DefaultExceptionHandler);
PROVIDE(__pre_init = default_pre_init);
PROVIDE(_setup_interrupts = default_setup_interrupts);
PROVIDE(_mp_hook = default_mp_hook);
PROVIDE(_start_trap = default_start_trap);
SECTIONS
{
.text.dummy (NOLOAD) :
{
/* This section is intended to make _stext address work */
. = ABSOLUTE(_stext);
} > REGION_TEXT
.text _stext :
{
/* Put reset handler first in .text section so it ends up as the entry */
/* point of the program. */
KEEP(*(.init));
KEEP(*(.init.rust));
. = ALIGN(4);
(*(.trap));
(*(.trap.rust));
*(.text .text.*);
} > REGION_TEXT
.rodata : ALIGN(4)
{
*(.srodata .srodata.*);
*(.rodata .rodata.*);
/* 4-byte align the end (VMA) of this section.
This is required by LLD to ensure the LMA of the following .data
section will have the correct alignment. */
. = ALIGN(4);
} > REGION_RODATA
.data : ALIGN(4)
{
_sidata = LOADADDR(.data);
_sdata = .;
/* Must be called __global_pointer$ for linker relaxations to work. */
PROVIDE(__global_pointer$ = . + 0x800);
*(.sdata .sdata.* .sdata2 .sdata2.*);
*(.data .data.*);
. = ALIGN(4);
_edata = .;
} > REGION_DATA AT > REGION_RODATA
.bss (NOLOAD) :
{
_sbss = .;
*(.sbss .sbss.* .bss .bss.*);
. = ALIGN(4);
_ebss = .;
} > REGION_BSS
/* fictitious region that represents the memory available for the heap */
.heap (NOLOAD) :
{
_sheap = .;
. += _heap_size;
. = ALIGN(4);
_eheap = .;
} > REGION_HEAP
/* fictitious region that represents the memory available for the stack */
.stack (NOLOAD) :
{
_estack = .;
. = ABSOLUTE(_stack_start);
_sstack = .;
} > REGION_STACK
/* fake output .got section */
/* Dynamic relocations are unsupported. This section is only used to detect
relocatable code in the input files and raise an error if relocatable code
is found */
.got (INFO) :
{
KEEP(*(.got .got.*));
}
.eh_frame (INFO) : { KEEP(*(.eh_frame)) }
.eh_frame_hdr (INFO) : { *(.eh_frame_hdr) }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
pub struct Task {
//任务栈顶指针，很重要，任务首次启动或者上下文切换时要用到
pub(crate) sp: usize,
//任务栈空间，就是动态申请的一块内存空间，例如：4k字节，32为CPU的话usize=4字节，所以stack的长度为4k/4
pub(crate) stack: *mut usize,
//任务入口，真正执行任务逻辑的地方，任务首次运行PC值就是这个符号的地址，这个地址在任务初始化时被保存在上面的stack里

pub(crate) entry: Func,
//任务延时tick计数器，每tick一次减1，直到为0时表示延时结束，重新进入就绪队列等待下一次tick到来时调度
pub(crate) remaining_ticks: usize,
//任务ID，任务唯一的标识
pub(crate) id: u16,
//任务优先级，任务排序用，值越小优先级越高，调度器会优先调度
pub(crate) priority: u8,
//任务状态，记录任务当前的状态，典型的值有Ready（就绪）、Running（正在运行）、Suspended（挂起）、Blocked（阻塞）、Terminated（终止）
pub(crate) state: State,
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

/// 任务创建时为CPU准备好任务的现场，一共32个参数，占用36*4个字节
/// 包括入口函数、任务参加、返回地址、任务栈顶指针
/// 这段程序与汇编中实现的上文保存是同一个功能，唯一不同的是
/// 任务初始化时栈顶就是数组的尾地址，任务运行过程中栈顶的位置是不确定的，因为不知道任务函数里定义了多少变量，一个变量就要占一份栈空间
///
/// 0. 任务栈SP保存在任务sp字段，也是任务的第一个参数
/// 1. 任务入口函数就是当任务被第一次运行时的PC地址，保存在mepc寄存器中，
/// 2. 任务函数参数保存在a0寄存器中，寄存器编号为x10
/// 3. 任务返回地址保存在ra寄存器中，寄存器编号为x1
/// 4. 其他通用寄存器按约定的顺序保存在任务堆栈中即可
#[inline]
fn save_context(task: &mut Task) {
unsafe {
//任务栈指针移到栈顶，也就是数组的最后一个元素起始位置
let sp = task.stack.add(task.stack_size - 1);
/*
*
从任务栈顶开始压栈，压栈顺序如下，一共32个值，占用36*4字节任务栈空间
*
mcause=0xb8000000，30:31为中断号（7），0:29为异常原因
*
msubm(0x7c4)=0x40，自定义寄存器用于保存Core当前的Trap类型，以及进入Trap前的Trap类型。详见《Bumblebee内核指令架构手册》
*
mepc=task.entry，出栈后mret指令会用mepc的值赋值给PC，这样就可以进入用户任务函数了
*
mstatus=0x000000C80，mpp[11:12]和mpie[7]置位，mpp在机器模式==11，mpie=1当任务恢复后打开全局中断
*
x31-x11 默认0
*
x10(a0)=task.args，任务函数参数
*
x9-x2 默认0
*
x1(ra)=task_exit_error，任务返回地址
*
x0 保留，任务栈sp指向这里
*/
sp.offset(-1).write_volatile(0xb8000000);
sp.offset(-2).write_volatile(0x40);
sp.offset(-3)
.write_volatile((task.entry as *const ()).addr());
sp.offset(-4).write_volatile(0x00000C80);
sp.offset(-26).write_volatile(task.args.addr());
sp.offset(-35)
.write_volatile((port::task_exit as *const ()).addr());
task.sp = sp.offset(-36).addr();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/// 这个函数如果返回true，就说明有就绪任务，需要把当前任务切换掉，其实就是一条指令产生一个软中断，然后CPU会进入软中断服务程序里完成真正的切换，往下看下面一个函数就是
fn do_systick(&self) -> bool {
unsafe {
//从延时任务队列里扫描所有任务，并更新延时的remaining_ticks-=1，同时收集remaining_ticks==0的任务索引号
if let Some(delay) = &mut DELAY {
let readys: Vec<usize> = delay
.iter()
.enumerate()
.filter_map(|(i, task)| {
if let Some(task) = (*task).as_mut() {
if task.tick() {
Some(i)
} else {
None
}
} else {
None
}
})
.collect();
//这段代码就是把remaining_ticks==0（延时时间到了）的任务从延时队列里删除，并重新放到就绪队列里，submit_task这个函数会根据任务的状态值分发到不同的队列里
readys.iter().for_each(|i| {
if let Some(task) = delay.remove(*i) {
submit_task(task);
}
});
}
// 检查尾导零，是否有比当前任务相等或更高优先级的任务
// 如果想等优先级则时间片调度，否则就一直抢占着，直到任务主动挂起
// TODO 需改进 ARM CLZ指令计算前导零
let trailing_zero = READY_BITS.trailing_zeros();
trailing_zero < 16 && (trailing_zero + 1) <= self.current().priority as u32
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// 保存上文宏
.macro SAVE_CONTEXT_SOFT_IRQ
// 开辟一块栈空间（栈操作快就是这个道理，加减下SP就行）
// SP向下偏移36个字，也就是任务被切走后的任务栈顶
addi sp, sp, -36 * 4
// 把x1写入sp偏移4字节的位置，0(sp)位置保留给x0寄存器，很等于0
sw x1, 1 * 4(sp) //ra(return address)//返回地址
// 保留x2,x3,x4栈空间，有点浪费～，但是看起来对齐比较舒服
sw x5, 5 * 4(sp) //t0(temporary)/lr(link register)t[x]临时寄存器
sw x6, 6 * 4(sp) //t1(temporary)
sw x7, 7 * 4(sp) //t2(temporary)
sw x8, 8 * 4(sp) //s0/fp(frame pointer) //s[x]保存寄存器/帧指针
sw x9, 9 * 4(sp) //s1(saved register)
sw x10, 10 * 4(sp) //a0(funcation arguments)/rtval(return value)//入参/返回值地址
sw x11, 11 * 4(sp) //a1(funcation arguments)/rtval(return value)//入参/返回值地址
sw x12, 12 * 4(sp) //a2(funcation arguments)//a[x]入参地址
sw x13, 13 * 4(sp) //a3(funcation arguments)
sw x14, 14 * 4(sp) //a4(funcation arguments)
sw x15, 15 * 4(sp) //a5(funcation arguments)
sw x16, 16 * 4(sp) //a6(funcation arguments)
sw x17, 17 * 4(sp) //a7(funcation arguments)
sw x18, 18 * 4(sp) //s2(saved register)
sw x19, 19 * 4(sp) //s3(saved register)
sw x20, 20 * 4(sp) //s4(saved register)
sw x21, 21 * 4(sp) //s5(saved register)
sw x22, 22 * 4(sp) //s6(saved register)
sw x23, 23 * 4(sp) //s7(saved register)
sw x24, 24 * 4(sp) //s8(saved register)
sw x25, 25 * 4(sp) //s9(saved register)
sw x26, 26 * 4(sp) //s10(saved register)
sw x27, 27 * 4(sp) //s11(saved register)
sw x28, 28 * 4(sp) //t3(temporary)
sw x29, 29 * 4(sp) //t4(temporary)
sw x30, 30 * 4(sp) //t5(temporary)
sw x31, 31 * 4(sp) //t6(temporary)
// CSR寄存器压栈，
csrr t0, mstatus
sw t0, 32 * 4(sp)
csrr t0, mepc // 当前任务的下一条指令的PC地址，也就是当前PC+4
sw t0, 33 * 4(sp) // PC地址入栈
csrr t0, 0x7C4 // Bumblebee内核
sw t0, 34 * 4(sp)
csrr t0, mcause
sw t0, 35 * 4(sp)
.endm
// 恢复下文，和上面的上文对齐即可
.macro REsw_CONTEXT_SOFT_IRQ
lw x1, 1 * 4(sp) // 任务返回地址
lw x5, 5 * 4(sp)
lw x6, 6 * 4(sp)
lw x7, 7 * 4(sp)
lw x8, 8 * 4(sp)
lw x9, 9 * 4(sp)
lw x10, 10 * 4(sp) // a0，任务参数
lw x11, 11 * 4(sp)
lw x12, 12 * 4(sp)
lw x13, 13 * 4(sp)
lw x14, 14 * 4(sp)
lw x15, 15 * 4(sp)
lw x16, 16 * 4(sp)
lw x17, 17 * 4(sp)
lw x18, 18 * 4(sp)
lw x19, 19 * 4(sp)
lw x20, 20 * 4(sp)
lw x21, 21 * 4(sp)
lw x22, 22 * 4(sp)
lw x23, 23 * 4(sp)
lw x24, 24 * 4(sp)
lw x25, 25 * 4(sp)
lw x26, 26 * 4(sp)
lw x27, 27 * 4(sp)
lw x28, 28 * 4(sp)
lw x29, 29 * 4(sp)
lw x30, 30 * 4(sp)
lw x31, 31 * 4(sp)
// CSR寄存器出栈
lw t0, 32 * 4(sp)
csrw mstatus, t0 // 恢复mstatus
lw t0, 33 * 4(sp)
csrw mepc, t0 // 恢复任务PC到mepc寄存器，最后由mret伪指令恢复到PC寄存器
lw t0, 34 * 4(sp)
csrw 0x7C4, t0 // Bumblebee内核自定义寄存器
lw t0, 35 * 4(sp)
csrw mcause, t0 // 恢复mcause
// SP指针上移，释放当前任务的栈空间，使SP指向任务被切换前的栈顶
addi sp, sp, 4 * 36
.endm
// 当前任务全局指针，在RUST代码中定义
.extern CURRENT_TASK_PTR
// IRQ entry point
.section .text.irq
.option push
.option norelax
.align 2
.option pop
.global _irq_handler
_irq_handler:
// 保存上文到任务堆栈
SAVE_CONTEXT_SOFT_IRQ
// 把当前任务的SP保存到任务栈
// CURRENT_TASK_PTR是当前任务的指针，指向了当前运行任务的地址，在RUST代码里维护
lw t0, CURRENT_TASK_PTR
sw sp, 0x0(t0)
// 切到中断栈
csrrw sp, mscratch, sp
// Bumblebee内核自定义寄存器实现了中断嵌套，跳转到中断向量表地址
// 执行这条指令后全局中断被打开mie=1，通过ra地址指向这条指令自己
// 实现了中断嵌套的功能，所以向量表里的定义的ISR服务函数不需要再
// 开关中断，中断服务程序不会被其他中断打断（除非发了不可屏蔽异常，
// 例如硬件错误），中断服务函数执行的CPU被独占着，所以中断服务函数
// 执行效率决定了多任务的响应能力、吞吐量、CPU利用率等关键指标
csrrw ra, 0x7ED, ra
// 退出0x7ED后关闭全局中断mie=0
// csrc表示清除CSR寄存器指定位的值
// 这里就表示清除mstatus寄存器mie位的值
csrc mstatus, 0x00000008
// 回到任务栈
csrrw sp, mscratch, sp
// 这个时候已经切换到新的任务，需要从新任务的栈空间恢复下文，栈顶地址就保存在任务第一个变量里
lw t0, CURRENT_TASK_PTR
// 这个任务栈地址要么是第一次创建的时候写入任务块的，要么是被切换走的时候写入任务块的
lw sp, 0x0(t0)
// 恢复下文到CPU寄存器
REsw_CONTEXT_SOFT_IRQ
// mepc值已经在上面恢复，执行这条伪指令将PC指向新任务断点处
// 同时mie从mpie恢复到中断前的状态，也就是要恢复到进入中断函数前的中断状态
mret

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 找到一个就绪任务把当前任务切出去
fn do_schedule(&self) {
unsafe {
//弹出一个就绪任务，把全局任务指向新的任务地址即可
let new = pop_ready();
if new != xworker.current() {
if let Some(new) = new.as_mut() {
if let Some(old) = xworker.execute(new).and_then(|item| item.as_mut()) {
//检查是否栈溢出
old.stack_overflow();
submit_task(old);
}
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

/// 配置定时器、软中断、使能定时器中断和软中断
#[inline]
pub(crate) fn setup_intrrupt() {
unsafe {
//设置定时器中断
ECLIC::setup(
//定时器中断号
Interrupt::INT_TMR,
//上升沿触发
TriggerType::RisingEdge,
//中断等级
Level::L0,
//中断优先级
Priority::P0,
);
//设置软中断
ECLIC::setup(
//软中断号
Interrupt::INT_SFT,
//上升沿触发
TriggerType::RisingEdge,
//中断等级
Level::L0,
//中断优先级
Priority::P0,
);
//定时器中断使能
ECLIC::unmask(Interrupt::INT_TMR);
//软中断使能
ECLIC::unmask(Interrupt::INT_SFT);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// 调度器启动时恢复第一个任务到CPU寄存器
//关全局中断
csrc mstatus, 0x00000008
// 获取link.x链接文件中_stack_start栈顶地址，因为这个函数不会返回，所以
// 当函数结束时还会留下一部分栈空间，这部分空间作为中断服务函数栈使用，以提
// 高内存利用率，同时，留512字节空间给启动函数，因为启动函数可能已经占用了
// 一部分堆栈空间，硬件启动栈空间是2k，剩下的1.5k作为中断栈使用
// 把栈顶地址保存到mscratch备用寄存器，当进入中断服务函数时可以拿出来给中断函数用
la t0, _stack_start
addi t0, t0, -512
csrw mscratch, t0
// 加载当前任务块地址
lw t0, CURRENT_TASK_PTR
// SP指向任务栈栈顶，任务块第一个变量就是指向任务栈顶
lw sp, 0x0(t0)
// 从栈顶出栈恢复CPU状态
// 通用寄存器出栈操作
lw x1, 1 * 4(sp) // 任务返回地址
lw x5, 5 * 4(sp)
lw x6, 6 * 4(sp)
lw x7, 7 * 4(sp)
lw x8, 8 * 4(sp)
lw x9, 9 * 4(sp)
lw x10, 10 * 4(sp) // a0，任务参数
lw x11, 11 * 4(sp)
lw x12, 12 * 4(sp)
lw x13, 13 * 4(sp)
lw x14, 14 * 4(sp)
lw x15, 15 * 4(sp)
lw x16, 16 * 4(sp)
lw x17, 17 * 4(sp)
lw x18, 18 * 4(sp)
lw x19, 19 * 4(sp)
lw x20, 20 * 4(sp)
lw x21, 21 * 4(sp)
lw x22, 22 * 4(sp)
lw x23, 23 * 4(sp)
lw x24, 24 * 4(sp)
lw x25, 25 * 4(sp)
lw x26, 26 * 4(sp)
lw x27, 27 * 4(sp)
lw x28, 28 * 4(sp)
lw x29, 29 * 4(sp)
lw x30, 30 * 4(sp)
lw x31, 31 * 4(sp)
// CSR寄存器出栈
lw t0, 32 * 4(sp)
csrw mstatus, t0 // 恢复mstatus，当mret时mie=mpie，即打开全局中断
lw t0, 33 * 4(sp)
csrw mepc, t0 // 任务入口函数在这里，也是PC地址
lw t0, 34 * 4(sp)
csrw 0x7c4, t0 // 自定义寄存器
lw t0, 35 * 4(sp)
csrw mcause, t0 // 保存异常代码
// 释放栈空间，栈指针上移，
// 任务块栈顶指针的值还是保持在原来的地方，这里更
// 不更新无所谓，因为任务已经在运行，当被切换掉时会被更新掉
addi sp, sp, 4 * 36
// 这条伪指令CPU就开始执行任务函数了，使PC=mepc，mie=mpie
mret

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

pub struct Notifier {
blocker: Rc<usize>,
//当前挂起者任务指针
signal: Rc<AtomicBool>, //信号标记，智能指针包下，防止move过程中地址里的值被转移到其他任务栈
}
impl Notifier {
pub fn new() -> Self {
Self {
blocker: Rc::new(0),
signal: Rc::new(AtomicBool::new(false)),
}
}
}
unsafe impl Send for Notifier {}
impl Notifier {
#[inline]
unsafe fn block(&self) {
let task = xworker.current();
let addr = (task as *mut Task).addr();
core::ptr::write_volatile(self.blocker.as_ref() as *const _ as *mut usize, addr);
task.block();
}
#[inline]
unsafe fn wakeup(&self) {
let blocker = core::ptr::read_volatile(self.blocker.as_ref());
if blocker != 0 {
let blocker = &mut *(blocker as *mut Task);
core::ptr::write_volatile(self.blocker.as_ref() as *const _ as *mut usize, 0);
blocker.wakeup();
}
}
/// 产生一个信号，如果信号写入
/// 成功则唤醒挂起的任务否则报错
pub fn notify_isr(&self) -> nb::Result<(), Error> {
match self
.signal
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
{
Ok(_) => unsafe {
self.wakeup();
Ok(())
},
Err(_) => Err(nb::Error::WouldBlock),
}
}
/// 产生一个信号，如果信号写入
/// 成功则唤醒挂起的任务，如果
/// 信号写入失败则挂起自己
pub fn notify(&self) {
loop {
match self
.signal
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
{
Ok(_) => {
sync::free(|_| unsafe {
self.wakeup();
});
break;
}
Err(_) => {
sync::free(|_| unsafe {
self.block();
});
yield_now();
}
}
}
}
/// 等待一个信号
/// 如果有信号则唤醒通知者，否则挂起自己
pub fn wait(&self) {
loop {
match self
.signal
.compare_exchange(true, false, Ordering::SeqCst, Ordering::SeqCst)
{
Ok(_) => {
sync::free(|_cs| unsafe {
self.wakeup();
});
break;
}
Err(_) => {
sync::free(|_cs| unsafe {
self.block();
});
yield_now();
}
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

/// 信号量
/// 设计思想是维护两个任务挂起队列
/// 当信号量为零时挂起当前任务到挂起队列
/// 当信号量大于零时从挂起队列弹出任务交给调度器
pub struct Semaphore {
waiters: Rc<RefCell<TaskQueue>>,
notifiers: Rc<RefCell<TaskQueue>>,
signal: Rc<AtomicUsize>, //信号量
max_value: usize,
}
impl Semaphore {
pub fn new() -> Self {
Self::with_signal(0)
}
pub fn with_signal(signal: usize) -> Self {
Self::with_signal_max_value(signal, usize::MAX)
}
pub fn with_max_value(max_value: usize) -> Self {
Self::with_signal_max_value(0, max_value)
}
pub fn with_signal_max_value(signal: usize, max_value: usize) -> Self {
Self {
waiters: Rc::new(RefCell::new(TaskQueue::new())),
notifiers: Rc::new(RefCell::new(TaskQueue::new())),
signal: Rc::new(AtomicUsize::new(signal)),
max_value: max_value,
}
}
}
impl Semaphore {
/// 发送信号
/// 可以在中断服务中使用
///
pub fn post_isr(&self) -> nb::Result<(), Error> {
if self.signal.fetch_add(1, Ordering::SeqCst) <= self.max_value {
unsafe {
if let Some(waiter) = self.waiters.borrow_mut().pop_front() {
if let Some(waiter) = waiter.as_mut() {
waiter.wakeup();
}
}
};
Ok(())
} else {
Err(nb::Error::Other(Error::SemaphoreFull))
}
}
/// 发送信号
/// 不能在中断服务中使用
pub fn post(&self) {
loop {
if self.signal.fetch_add(1, Ordering::SeqCst) <= self.max_value {
sync::free(|_| unsafe {
if let Some(waiter) = self.waiters.borrow_mut().pop_front() {
if let Some(waiter) = waiter.as_mut() {
waiter.wakeup();
}
}
});
break;
} else {
sync::free(|_| {
let task = xworker.current();
self.notifiers.borrow_mut().push_back(task as *mut Task);
task.block();
});
yield_now();
}
}
}
/// 等待一个信号量
/// 禁止在中断服务中调用
/// 注意：不要同时使用post_isr和post，不然可能会错误的唤醒poster
pub fn wait(&self) {
loop {
match self
.signal
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |signal| {
if signal == 0 {
None
} else {
Some(signal - 1)
}
}) {
Ok(_) => {
sync::free(|_| unsafe {
if let Some(poster) = self.notifiers.borrow_mut().pop_front() {
if let Some(poster) = poster.as_mut() {
poster.wakeup();
}
}
});
break;
}
Err(_) => {
sync::free(|_| {
let task = xworker.current();
self.waiters.borrow_mut().push_back(task);
task.block();
});
yield_now();
}
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

//! 多生产者，多消费者队列
//! 中断服务中使用请用xxx_isr方法
pub struct Queue<T> {
list: Rc<RefCell<VecDeque<T>>>,
sem: Semaphore,
}
impl<T> Queue<T> {
pub fn new() -> Self {
Self {
list: Rc::new(RefCell::new(VecDeque::new())),
sem: Semaphore::new(),
}
}
pub fn with_capacity(capacity: usize) -> Self {
Self {
list: Rc::new(RefCell::new(VecDeque::new())),
sem: Semaphore::with_max_value(capacity),
}
}
}
impl<T> Queue<T> {
pub fn pop_front(&self) -> Option<T> {
self.sem.wait();
sync::free(|_| self.list.borrow_mut().pop_front())
}
pub fn pop_back(&self) -> Option<T> {
self.sem.wait();
sync::free(|_| self.list.borrow_mut().pop_back())
}
pub fn push_front(&self, item: T) {
sync::free(|_| {
self.list.borrow_mut().push_front(item);
});
self.sem.post();
}
pub fn push_back(&self, item: T) {
sync::free(|_| {
self.list.borrow_mut().push_back(item);
});
self.sem.post();
}
pub fn push_front_isr(&self, item: T) -> nb::Result<(), sync::Error> {
self.list.borrow_mut().push_front(item);
match self.sem.post_isr() {
Ok(_) => Ok(()),
Err(_) => Err(nb::Error::Other(sync::Error::QueueFull)),
}
}
pub fn push_back_isr(&self, item: T) -> nb::Result<(), sync::Error> {
self.list.borrow_mut().push_back(item);
match self.sem.post_isr() {
Ok(_) => Ok(()),
Err(_) => Err(nb::Error::Other(sync::Error::QueueFull)),
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

// 大顶堆保存定时任务
static mut HEAP: Option<BinaryHeap<Box<TimerInner>>> = None;
// 就绪任务保存在数组里
static mut READY: Option<VecDeque<Box<TimerInner>>> = None;
static mut TIMER_TASK: *mut Task = core::ptr::null_mut();
pub(crate) fn start_timer_task() {
log::info!("start_timer_task");
unsafe {
if HEAP.is_none() {
HEAP = Some(BinaryHeap::new());
READY = Some(VecDeque::new());
}
let task = Task::new(
TIMER_TASK_NAME,
TIMER_STACK_SIZE_WORD,
1,
timer_task,
core::ptr::null_mut(),
);
if let Some(task) = task.as_mut() {
task.state = State::Suspended;
}
core::ptr::replace(&mut TIMER_TASK, task);
}
fn timer_task(_args: *mut c_void) {
loop {
sync::free(|_cs| unsafe {
if let Some(q) = &mut READY {
loop {
if let Some(mut t) = q.pop_front() {
(t.entry)(t.args);
if t.period > 0 {
t.next_tick = time::tick() + t.period as u64;
submit(t);
}
} else {
break;
}
}
}
let task = xworker.current();
task.block();
});
}
}
}
/// 扫描堆顶是否有超时定时任务
/// 有则唤醒工作任务，触发软中断
#[inline]
pub(crate) fn do_tick(ticks: u64) {
unsafe {
if let Some(heap) = &mut HEAP {
let mut ready = false;
if let Some(timer) = heap.peek() {
if ticks >= timer.next_tick {
ready = true;
}
}
if ready {
if let Some(timer) = heap.pop() {
if let Some(q) = &mut READY {
q.push_back(timer);
} else {
let mut q = VecDeque::new();
q.push_back(timer);
READY = Some(q)
}
}
if let Some(task) = TIMER_TASK.as_mut() {
task.wakeup();
}
yield_now();
}
}
}
}
#[repr(C)]
#[derive(Debug, Eq, Clone)]
struct TimerInner {
entry: Func,
//入口函数
args: *mut c_void, //参数
period: usize,
//周期
next_tick: u64,
//下次触发时间
}
impl Drop for TimerInner {
fn drop(&mut self) {
if self.period > 0 {
unsafe {
let _ = Box::from_raw(self.args as *mut Box<dyn Fn()>);
}
}
}
}
impl TimerInner {
fn after<F: FnOnce() + Send + 'static>(ms: usize, f: F) {
fn entry(args: *mut c_void) {
unsafe {
let b = Box::from_raw(args as *mut Box<dyn FnOnce()>);
b();
}
}
let f: Box<Box<dyn FnOnce() + Send + 'static>> = Box::new(Box::new(f));
let args = &*f as *const _ as *mut c_void;
let after = time::ms2ticks(ms);
let timer = Box::new(Self {
entry: entry,
args: args,
period: 0,
next_tick: time::tick() + after as u64,
});
core::mem::forget(f);
sync::free(|_| unsafe { submit(timer) });
}
fn period<F: Fn() + Send + 'static>(period_ms: usize, f: F) -> usize {
fn entry(args: *mut c_void) {
unsafe {
let b = Box::from_raw(args as *mut Box<dyn Fn()>);
b();
core::mem::forget(b);
}
}
let f: Box<Box<dyn Fn() + Send + 'static>> = Box::new(Box::new(f));
let args = &*f as *const _ as *mut c_void;
let period = time::ms2ticks(period_ms);
let timer = Box::new(Self {
entry,
args,
period,
next_tick: time::tick() + period as u64,
});
core::mem::forget(f);
let addr = timer.args.addr();
sync::free(|_| unsafe { submit(timer) });
addr
}
}
unsafe fn submit(timer: Box<TimerInner>) {
if let Some(heap) = &mut HEAP {
heap.push(timer);
} else {
let mut heap = BinaryHeap::new();
heap.push(timer);
HEAP = Some(heap);
}
}
pub struct Timer(usize);
impl Timer {
pub fn after<F: FnOnce() + Send + 'static>(ms: usize, f: F) {
TimerInner::after(ms, f)
}
pub fn period<F: Fn() + Send + 'static>(period_ms: usize, f: F) -> Timer {
Timer(TimerInner::period(period_ms, f))
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// 移植层接口定义
pub trait Portable {
/// 完全内存屏障
/// 保证在屏障之前的任何存储操作先于屏障之后的代码执行。
fn barrier();
/// 临界区保护函数
fn free<F, R>(f: F) -> R
where
F: FnOnce(&CriticalSection) -> R;
/// 开全局中断
fn enable_interrupt();
/// 关全局中断
fn disable_interrupt();
/// 启动调度器
fn start_scheduler() -> !;
/// 软中断
fn irq();
/// 关闭软中断
fn disable_irq();
/// 获取systick
fn systick() -> u64;
/// 硬件延时，单位us
fn delay_us(us: u64);
/// 保存任务环境到任务栈
fn save_context(task: &mut Task);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 导入汇编代码
global_asm!(include_str!("port.S"));
/**导出中断服务函数，导出名称必须与port.S汇编代码中定义的一致**/
/// riscv规定，进入中断函数前，全局中断被硬件自动关闭，mpie=mie，mie=0
/// 从中断函数退出后，mie被mpie恢复，恢复到中断前的中断状态
/// 注意，退出中断服务不是指退出当前这个函数，而是在汇编代码实现的_irq_handler函数
/// 定时中断服务函数，驱动任务调度，当有任务需求切换时触发软中断即可，
/// 任务切换由软中断服务函数实现，gd32里使用自定义寄存器（0x7ED）巧
/// 妙的实现了中断嵌套，工作职责清晰。
/// 当进入中断函数时SP已经在port.S汇编代码中切换到了中断栈，中断栈只
/// 有1.5k，所以函数不要嵌套太深，特别要防止递归调用
#[export_name = "INT_TMR"]
unsafe extern "C" fn mtimer_irq_isr() {
//isr_sprintln!("mtimer_irq_isr");
//设置下一次中断时间
super::reset_systick();
if scheduler::systick() {
super::Gd32vf103Porting::irq();
}
}
/// 软中断服务函数，这里只要实现任务切换即可，上下文保存
/// 在port.S汇编代码里实现，这个函数工作在中断栈，同样
/// 要注意函数嵌套和递归调用
///
/// 任务切换原理
/// 1.保存当然cpu状态到当前任务栈（port.S里实现）
/// 2.保存任务当前栈顶地址到任务块第一个变量里，将来任务被切回来时要用到
/// 3.关软中断，防止被再一次触发；根据调度算法选择合适的任务，把全局任务指针指向新的任务
/// 4.从新任务恢复cpu状态在port.S里实现）
#[export_name = "INT_SFT"]
unsafe extern "C" fn soft_irq_isr() {
//关闭软中断
super::Gd32vf103Porting::disable_irq();
scheduler::schedule();
}
/// 所有任务的退出函数，调用exit函数即可
pub(crate) unsafe extern "C" fn task_exit() {
scheduler::exit_current_task();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

/// gd32芯片移植层实现
pub struct Gd32vf103Porting;
impl Portable for Gd32vf103Porting {
/// 完全内存屏障
/// 保证在屏障之前的任何存储操作先于屏障之后的代码执行。
#[inline]
fn barrier() {
unsafe {
riscv::asm::sfence_vma_all();
}
}
/// 临界区保护
#[inline]
fn free<F, R>(f: F) -> R
where
F: FnOnce(&CriticalSection) -> R,
{
riscv::interrupt::free(f)
}
/// 开全局中断
#[inline]
fn enable_interrupt() {
unsafe {
riscv::interrupt::enable();
}
}
/// 关全局中断
#[inline]
fn disable_interrupt() {
unsafe {
riscv::interrupt::disable();
}
}
/// 启动调度器
/// 1. 配置定时器中断、软中断触发类型和优先级
/// 2、把第一个任务恢复到CPU中，内联汇编实现
fn start_scheduler() -> ! {
reset_systick();
//配置中断，这个函数就是定时中断和软中断使能
setup_intrrupt();
log::info!("Start scheduler");
//从任务栈恢复CPU状态，汇编实现
unsafe { asm!(include_str!("restore_ctx.S")) };
//这个函数不会返回，因为在汇编中最后一条指令是mret，而不是ret
//mret把mepc更新到PC，而ret把ra更新到PC
panic!("~!@#$%^&*()_");
}
/// 软中断
/// 当软中断被打开时触发软中断，直到软中断或者全局中断关闭为止
#[inline]
fn irq() {
let ptr = (TIMER_CTRL_ADDR + TIMER_MSIP) as *mut u8;
unsafe {
ptr.write_volatile(*ptr | 0x01);
}
}
/// 关闭软中断
#[inline]
fn disable_irq() {
let ptr = (TIMER_CTRL_ADDR + TIMER_MSIP) as *mut u8;
unsafe {
ptr.write_volatile(*ptr & !0x01);
}
}
/// 读取计数器寄存器的值，保存了从CPU工作开始到现在的rtc tick数
/// mtime是个可读写且单调递增寄存器，通常不要去设置它，让它一直保存单调递增即可
/// 有两个32位寄存器组成，共64位，所以在已知的生命周期内不用考虑这个值的溢出
#[inline]
fn systick() -> u64 {
loop {
let hi = unsafe { *((TIMER_CTRL_ADDR + TIMER_MTIME + 4) as *mut u32) };
let lo = unsafe { *((TIMER_CTRL_ADDR + TIMER_MTIME) as *mut u32) };
if hi == unsafe { *((TIMER_CTRL_ADDR + TIMER_MTIME + 4) as *mut u32) } {
return (hi as u64) << 32 | (lo as u64);
}
}
}
/// 重新设置mtimecmp寄存器
/// mtimecmp=TICKS+mtime的值，当mtimecmp的值大于等于mtime时触发定时器中断
/// 硬件延时，单位us
#[inline]
fn delay_us(us: u64) {
let t0 = riscv::register::mcycle::read64();
let clock = (us * (CPU_CLOCK_HZ as u64)) / 1_000_000;
while riscv::register::mcycle::read64().wrapping_sub(t0) <= clock {}
}
/// 任务创建时为CPU准备好任务的现场，一共32个参数，占用36*4个字节
/// 包括入口函数、任务参加、返回地址、任务栈顶指针
/// 这段程序与汇编中实现的上文保存是同一个功能，唯一不同的是
/// 任务初始化时栈顶就是数组的尾地址，任务运行过程中栈顶的位置是不确定的
///
/// 0. 任务栈SP保存在任务sp字段，也是任务的第一个参数
/// 1. 任务入口函数就是当任务被第一次运行时的PC地址，保存在mepc寄存器中，
/// 2. 任务函数参数保存在a0寄存器中，寄存器编号为x10
/// 3. 任务返回地址保存在ra寄存器中，寄存器编号为x1
/// 4. 其他通用寄存器按约定的顺序保存在任务堆栈中即可
#[inline]
fn save_context(task: &mut Task) {
unsafe {
//任务栈指针移到栈顶，也就是数组的最后一个元素起始位置
let sp = task.stack.add(task.stack_size - 1);
// 需要8字节对齐，参考FreeRTOS，说是为了双精度浮点运算，还没搞明白，暂且注释掉
//sp = ((sp as usize) & !(0x0007)) as *mut usize;
/*
*
从任务栈顶开始压栈，压栈顺序如下，一共32个值，占用36*4字节任务栈空间
*
mcause=0xb8000000，30:31为中断号（7），0:29为异常原因
*
msubm(0x7c4)=0x40，自定义寄存器用于保存Core当前的Trap类型，以及进入Trap前的Trap类型。详见《Bumblebee内核指令架构手册》
*
mepc=task.entry，出栈后mret指令会用mepc的值赋值给PC，这样就可以进入用户任务函数了
*
mstatus=0x000000C80，mpp[11:12]和mpie[7]置位，mpp在机器模式==11，mpie=1当任务恢复后打开全局中断
*
x31-x11 默认0
*
x10(a0)=task.args，任务函数参数
*
x9-x2 默认0
*
x1(ra)=task_exit_error，任务返回地址
*
x0 保留，任务栈sp指向这里
*/
sp.offset(-1).write_volatile(0xb8000000);
sp.offset(-2).write_volatile(0x40);
sp.offset(-3)
.write_volatile((task.entry as *const ()).addr());
sp.offset(-4).write_volatile(0x00000C80);
sp.offset(-26).write_volatile(task.args.addr());
sp.offset(-35)
.write_volatile((port::task_exit as *const ()).addr());
task.sp = sp.offset(-36).addr();
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#[exception]
unsafe fn SVCall() {
asm!(
"
ldr r3, =CURRENT_TASK_PTR
ldr r1, [r3]
ldr r0, [r1]
ldmia r0!, {{r4-r11}}
msr psp, r0
isb
mov r14, #0xfffffffd
bx r14
"
)
}
/// 如果由Systict异常触发，那么xPSR、pc、sp等自动保存在主栈中
/// 如果由任务触发，那么xPSR、pc、sp等自动保存在任务栈中
#[exception]
unsafe fn PendSV() {
/// 不要调用任何函数，否则会改变r14的值，导致无法回到任务栈中
asm!(
"
mrs r0, psp
isb
ldr r3, =CURRENT_TASK_PTR
ldr r2, [r3]
stmdb r0!, {{r4-r11}}
str r0, [r2]
stmdb sp!, {{r3, r14}}
cpsid i
cpsid f
bl switch_context
cpsie f
cpsie i
ldmia sp!, {{r3, r14}}
ldr r1, [r3]
ldr r0, [r1]
ldmia r0!, {{r4-r11}}
msr psp, r0
isb
//恢复msp
ldr r0, =0xE000ED08 // 向量表地址，将 0xE000ED08 加载到 R0
ldr r0, [r0] //将 0xE000ED08 中的值，也就是向量表的实际地址加载到 R0
ldr r0, [r0] //根据向量表实际存储地址，取出向量表中的第一项,向量表第一项存储主堆栈指针MSP的初始值
msr msp, r0 //将堆栈地址写入主堆栈指针
bx r14
"
);
}
/// 系统节拍器中断
#[exception]
unsafe fn SysTick() {
const TICKS: u32 = SYSTICK_CLOCK_HZ as u32 / TICK_CLOCK_HZ as u32;
interrupt::free(|_| {
let tick = core::ptr::read_volatile(&SYSTICKS);
core::ptr::write_volatile(&mut SYSTICKS, tick + TICKS as u64);
if scheduler::systick() {
cortex_m::peripheral::SCB::set_pendsv();
}
});
}
/// 软中断切换任务
#[export_name = "switch_context"]
unsafe extern "C" fn switch_context() {
scheduler::schedule();
}
/// 所有任务的退出函数，调用exit函数即可
pub(crate) unsafe extern "C" fn task_exit() {
scheduler::exit_current_task();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

impl Portable for STM32F1Porting {
/// 完全内存屏障
/// 保证在屏障之前的任何存储操作先于屏障之后的代码执行。
fn barrier() {
cortex_m::asm::dsb();
}
fn free<F, R>(f: F) -> R
where
F: FnOnce(&CriticalSection) -> R,
{
unsafe { cortex_m::interrupt::free(|_| f(&CriticalSection::new())) }
}
/// 开全局中断
fn enable_interrupt() {
unsafe { cortex_m::interrupt::enable() }
}
/// 关全局中断
fn disable_interrupt() {
crate::arch::cortex_m::interrupt::disable()
}
/// 启动调度器
fn start_scheduler() -> ! {
//配置中断，这个函数就是定时中断和软中断使能
log::info!("Start scheduler");
//从任务栈恢复CPU状态，汇编实现
unsafe {
setup_intrrupt();
asm!(
"
mov r0, #0
msr control, r0	// sp=msp
cpsie i //使能全局中断
cpsie f //使能全局异常
dsb //数据同步，将流水线中的数据全部执行完毕
isb //指令同步，将流水线中的指令全部执行完毕
svc 0xff
//调用SVCall异常服务，在SVCall里恢复第一个任务
nop
"
)
};
panic!("~!@#$%^&*()_")
}
/// 软中断
fn irq() {
cortex_m::peripheral::SCB::set_pendsv();
cortex_m::asm::dsb();
cortex_m::asm::isb();
}
fn disable_irq() {
cortex_m::peripheral::SCB::clear_pendsv();
}
/// 获取rtc tick
fn systick() -> u64 {
unsafe { core::ptr::read_volatile(&port::SYSTICKS) }
}
/// 硬件延时，单位us
fn delay_us(us: u64) {
let clock = (us * (CPU_CLOCK_HZ as u64)) / 1_000_000;
cortex_m::asm::delay(clock as u32);
}
/// 保存任务环境到任务栈
fn save_context(task: &mut Task) {
unsafe {
//任务栈指针移到栈顶，也就是数组的最后一个元素起始位置
let mut sp = task.stack.add(task.stack_size - 1);
// sp = (sp.addr() & !0x0007) as *mut usize;
sp = sp.offset(-1);
sp.write_volatile(0x01000000); /* xPSR */
sp = sp.offset(-1);
sp.write_volatile((task.entry as *const ()).addr()); /* PC */
sp = sp.offset(-1);
sp.write_volatile((port::task_exit as *const ()).addr()); /* LR */
sp = sp.offset(-5); /* R12, R3, R2 and R1. */
sp.write_volatile(task.args.addr()); /* R0 */
sp = sp.offset(-8); /* R11, R10, R9, R8, R7, R6, R5 and R4. */
task.sp = sp.addr();
}
}
}