机器人制造师(三):从 0x1000 开始,如何让三个任务轮流运行
机器人制造师(三):从 0x1000 开始,如何让三个任务轮流运行
代码在 GitCode:AevumArk/Aevum。
关键词:GDT、分页、IDT、PIT、任务切换
一、一块铁,从戏台上下来
机械臂是一个惊人的铁块。可 “机器人” 这个词,不是一开始就落在铁上的。机器人的历史有一百年了,最早那段,不在车间,在戏台上。
1920 年,恰佩克写了一部戏,让一批造出来的 “人” 当奴隶干活,最后反抗人类;“robot” 这个词,就是从捷克语里的 “苦役” 来的。又过了四十一年,第一台只有一条手臂的机器才进通用汽车的车间,把烧红的铸件夹出来。一百年,机器人从戏台上的角色,变成车间里的铁块。
这块铁,我没有见过真的,只在视频和资料里看过。它有多重,停下来要多久,撞上来会怎样,我说不准。所以下面这些,只能算一次尝试解读:代码从 0x1000 开始,把三个任务轮起来;屏幕上的画面是真的,铁块本身还停在资料里。
二、五百一十二字节的起点
这台机器真正的起点,不在车间,在一块 512 字节的引导扇区里。加电以后,BIOS 把它搬到 0x7C00;它再把后面 40 个扇区读到 0x1000。从那一个地址开始,没有 Linux,没有现成的调度器,只有一段自己写的代码。它先要做的不是算关节角,是让 CPU 从 16 位走到 32 位,把 GDT 和页表立起来。
引导扇区只做一件事:把内核从盘上搬到内存里,然后把这台机器交给下一段代码。
; boot.asm 主引导扇区 512 字节
[bits 16]
[org 0x7c00]
start:
mov ax, 0
mov es, ax
mov bx, 0x1000 ; 第二阶段落到 0x1000
mov ah, 0x02 ; BIOS 读扇区
mov al, 40 ; 读 40 个扇区,20KB
mov ch, 0 ; 磁道 0
mov cl, 2 ; 从第 2 扇区开始,第 1 扇区是引导扇区自己
mov dh, 0 ; 磁头 0
int 0x13
jc disk_error
cli
lgdt [gdt_desc]
mov eax, cr0
or eax, 1
mov cr0, eax
jmp 0x08:pm_entry ; 远跳,刷新 CS
AH=02 是读盘,AL=40 是读四十个扇区,ES:BX 是落点,CH/CL/DH 指向第 2 扇区。读失败就停在 jc disk_error,不带着半截内核往下走。最后两个字节必须是 55 AA,少一个,BIOS 就不认这块盘。
四十个扇区是 20,480 字节,从 0x1000 起,正好到 0x6000。内核镜像现在 20,276 字节,塞得下;再多 204 字节,就出界。超出的部分不会被读进来,内存里是 0,跑到那里取指,CPU 就掉进一片空地址。
三、0x1000 只是地址,不是模式
字节到了 0x1000,CPU 还没到 32 位。这时候的 CS 还是 0,CPU 还在实模式。
实模式按 “段基址乘 16,加偏移” 算地址,最多 1MB;没有权限级别,没有页表。任何一段代码都能写任何一段内存,内核、显存、任务栈混在一起。C 编译器吐出来的是 32 位指令,寄存器、寻址、栈都是 32 位的;在实模式里,它不认。
保护模式换的是另一套段规则:段寄存器不再直接存基址,存的是选择子;选择子指向 GDT 里的一项,CPU 拿这一项去填自己的隐藏寄存器:基址、限长、权限。地址空间可以到 4GB,段可以带权限和限长,CPU 有 ring 0 到 ring 3 的特权级。
问题就在这里:0x1000 只是地址,模式还没换。代码到了,段规则还没到。
四、GDT:先把段规矩立起来
CPU 要进保护模式,先要一张段表。
GDT 是一张段表:哪一段是代码,哪一段是数据,从哪开始,到哪结束,能不能写。CPU 只认这张表。
GDT 里的一项叫描述符,段寄存器里存的是选择子。选择子高 13 位是 GDT 索引,第 2 位选 GDT 还是 LDT,低 2 位是请求特权级。所以 0x08 不是地址,它是 “GDT 第 1 项,TI=0,RPL=0”;0x10 是 “GDT 第 2 项”。
GDT 写出来只有三项:空项、代码段、数据段。
gdt_start:
dq 0 ; 空描述符,CPU 规定第 0 项不能用
gdt_code:
dw 0xffff ; 限长低 16 位
dw 0 ; 基址低 16 位
db 0 ; 基址中 8 位
db 0x9a ; P=1, DPL=0, S=1, Type=1010(代码,可读)
db 0xcf ; G=1(4KB 粒度), D/B=1(32 位)
db 0 ; 基址高 8 位
gdt_data:
dw 0xffff
dw 0
db 0
db 0x92 ; P=1, DPL=0, S=1, Type=0010(数据,可读写)
db 0xcf
db 0
gdt_end:
gdt_desc:
dw gdt_end - gdt_start - 1
dd gdt_start
0x9a 的二进制是 1001 1010:P=1,DPL=00,S=1,Type=1010。0x92 是 1001 0010:P=1,DPL=00,S=1,Type=0010。0xcf 的 G=1,限长按 4KB 放大;D/B=1,段是 32 位;限长 0xfffff 放大后就是 4GB。
基址全是 0,代码段和数据段都从 0 开始,C 代码不用再管分段。这就是 “平坦模型”。
GDT 准备好以后,用 lgdt 把基址和限长装进 GDTR:
lgdt [gdt_desc]
gdt_desc 是 6 字节:低 2 字节是限长,高 4 字节是 GDT 基址。这时候 CPU 还没进保护模式,但 GDTR 已经知道 GDT 在哪、有多长。
这里有一个实际踩过的坑:GDT 原来在引导扇区尾部 0x7c97,任务栈从 0x7000 起,会盖到它。所以 loader.asm 进 32 位以后,先把 24 字节 GDT 搬到 0x12800,再 lgdt。
mov esi, 0x7c97
mov edi, 0x12800
mov ecx, 24
rep movsb
lgdt [gdtr_new]
gdtr_new 里的限长是 0x17,也就是 24 字节减一;基址是 0x12800。不搬,后面任务一跑,GDT 就被栈写坏,下一次装段寄存器直接 triple fault。
五、PE 打开以后,还要远跳一次
GDT 立好了,CS 还在实模式,没有一条远跳接住它。PE 还没开,lgdt 只是把 GDT 的基址和限长装进 GDTR,真正切模式的是 CR0 的第 0 位,PE。
cli ; 切模式过程中不能被时钟打断
lgdt [gdt_desc]
mov eax, cr0
or eax, 1 ; 置 bit0,PE=1
mov cr0, eax
jmp 0x08:pm_entry ; 0x08 是代码段选择子
只写 PE 不够。CS 里还缓存着实模式的那套东西;必须用一次远跳,把 CS 重新装成代码段选择子。近跳只改 IP,不改 CS,跳过去还是在实模式里执行。
jmp 0x08:pm_entry 是远跳:0x08 是代码段选择子,pm_entry 是段内偏移。CPU 用选择子去 GDT 取描述符,刷新 CS 的隐藏寄存器,然后从新的 32 位代码段取指。
这一步最容易死的地方是:PE 开了,但没有远跳。CS 还缓存着实模式的段,CPU 可能继续按旧规则取指,一遇到异常就 triple fault。屏幕黑,机器重启,什么都看不到。
六、页表:0 到 4MB 铺平
PE 开了,CS 也远跳了。地址还是物理地址,页表还没铺。保护模式一开,地址是 32 位平坦地址,但还只是物理地址。要开分页,得先建两级表:页目录里放页表的地址,页表里放物理页的地址。CPU 的 CR3 指向页目录,CR0 的 PG 位打开以后,所有地址先过这张表,再到物理内存。
页目录有 1024 项,每项 4 字节,表项叫 PDE,指向一个页表;页表有 1024 项,每项 4 字节,表项叫 PTE,指向一个 4KB 物理页。
CR3 -> 页目录 -> 页表 -> 物理页
页目录放在 0x10000,页表放在 0x11000。两块内存清零后,再填第 0 项。
; 清空页目录 0x10000
mov edi, 0x10000
mov ecx, 1024
xor eax, eax
rep stosd
; 页目录第 0 项:指向页表 0x11000,Present + RW
mov dword [0x10000], 0x11003
; 清空页表 0x11000
mov edi, 0x11000
mov ecx, 1024
xor eax, eax
rep stosd
; 填充页表:虚拟地址 0~4MB 映射到物理地址 0~4MB
mov ebx, 0x11000
mov eax, 0x00000003
mov ecx, 1024
fill_pt:
mov [ebx], eax
add ebx, 4
add eax, 0x1000
loop fill_pt
mov eax, 0x10000
mov cr3, eax
mov eax, cr0
or eax, 0x80000000 ; 置 bit31,PG=1
mov cr0, eax
jmp 0x08:0x1000
0x11003 的低 12 位是标志:Present、RW;高位是页表物理地址 0x11000。页表项从 0x00000003 开始,每项加 0x1000,1024 项正好覆盖 4MB。CR3 = 0x10000 指向页目录,CR0.PG = 1 打开分页,最后 jmp 0x08:0x1000 跳到内核主入口。
这是恒等映射:虚拟地址 0 到 4MB 映射到物理地址 0 到 4MB。内核自己、显存、栈、任务空间都在低 4MB 里,所以一张页表就够。
这里没有做按需分页。所有页在启动时先映射好,缺页不拿来补页。机器人控制环最怕走到一半缺页,那一停不是几个微秒,是整条环断掉。页表少一项,开 PG 的下一行指令就取不到;CPU 三重故障,连 Page Fault 都来不及打印。
还有 A20。真机上要摸到 1MB 以上,A20 得打开;这份代码没有单独写 A20,依赖 BIOS/QEMU 进来时的状态。换到真机,这一步要自己补。不打开,地址第 20 位被压住,超过 1MB 的访问会回卷。
七、到了 0x1000,C 还没有栈
页表铺好了,C 的栈还没落地。boot.asm 用 jmp 0x08:0x1000 跳进第二阶段。第二阶段入口是 loader.asm。它到 0x1000 后,清 BSS、搬 GDT、设 C 栈;第一件事不是写业务,是把 C 运行需要的段、BSS 和栈收拾好。
BSS 没清,全局变量留着上一轮内存的值;current_task 一开跑就可能是野指针,第一次调度直接跳飞。
[bits 32]
global start
extern kernel_main
extern __bss_start
extern __bss_end
section .text
start:
cld
mov edi, __bss_start
mov ecx, __bss_end
sub ecx, edi
xor eax, eax
rep stosb
mov esi, 0x7c97
mov edi, 0x12800
mov ecx, 24
rep movsb
lgdt [gdtr_new]
mov esp, 0xB000
call kernel_main
boot.asm 只读 40 个扇区,也就是 20KB;BSS 可能长过这个窗口,所以不能指望磁盘镜像里带进来,必须由 loader.asm 自己清零。__bss_start、__bss_end 是链接脚本给的符号,不是手写的常量。
C 栈放在 0xB000。任务栈从 0x7000 到 0xE000,页目录和页表在 0x10000、0x11000,IDT 在 0x12000,GDT 副本在 0x12800。这些地址彼此让开:任务栈不会盖到页表,页表不会压到 IDT。
进 C 之前,还有一张帧布局要先定下来。中断进来时,CPU 已经压了 eflags/cs/eip;汇编桩再补 err/vector,然后按固定顺序压寄存器:
eax ebx ecx edx esi edi ebp vector err eip cs eflags
这张帧不是随便排的。C 里的 struct irq_frame 按同样的顺序读;任务第一次启动时,也按同样的槽位造一帧。帧槽错一个,iret 就会把 cs 当 eip,跳到一个不是入口的地址。
kernel_main 的顺序也只有一条:
void kernel_main(void)
{
vga_init();
uart_init();
task_boot();
arm_app_init();
cli();
interrupt_init();
arm_app_start();
for (;;) {
cli();
hlt();
}
}
先建任务表,再装 IDT/PIC/PIT,最后 arm_app_start() 用 int 0x40 切到第一个任务。第一个任务的 eflags 里带着 IF,iret 过去以后,时钟中断才真的能开始抢占。
八、时钟怎么进来
地址管住了,中断还没接上。CPU 要能被打断,否则一个死循环就能把整台机器占住。
IDT 放在 0x12000,256 项,每项 8 字节:
struct idt_entry {
u16 off_low;
u16 selector;
u8 zero;
u8 flags;
u16 off_high;
} __attribute__((packed));
struct idt_ptr {
u16 limit;
u32 base;
} __attribute__((packed));
#define IDT_ENTRIES 256
#define IDT_BASE 0x12000u
idt 是 256 项的表,idtr 是 lidt 要的 6 字节指针。实际代码只开了两个门:0x20 给 IRQ0,0x40 给软件调度。异常门还没填。
static void idt_set_gate(int vector, void (*handler)(void))
{
u32 address = (u32)handler;
idt[vector].off_low = (u16)(address & 0xFFFFu);
idt[vector].selector = 0x08;
idt[vector].zero = 0;
idt[vector].flags = 0x8E;
idt[vector].off_high = (u16)(address >> 16);
}
0x8E 的二进制是 1000 1110:P=1,DPL=00,Type=1110,32 位中断门。选择子是 0x08,和代码段同一个选择子。
异常门没填。异常一来,IDT 里是空项,CPU 三重故障。现在只做到时钟和软件调度,异常处理还没开始。
PIC 和 PIT 的寄存器不在内存里,在端口空间里;端口读写只靠两条内联汇编:outb 写,inb 读。
#define PIC1_CMD 0x20
#define PIC1_DATA 0x21
#define PIC2_CMD 0xA0
#define PIC2_DATA 0xA1
#define PIT_CMD 0x43
#define PIT_CH0 0x40
#define PIT_DIVISOR (1193182u / 100u)
static void pic_remap(void)
{
outb(PIC1_CMD, 0x11);
outb(PIC2_CMD, 0x11);
outb(PIC1_DATA, 0x20);
outb(PIC2_DATA, 0x28);
outb(PIC1_DATA, 0x04);
outb(PIC2_DATA, 0x02);
outb(PIC1_DATA, 0x01);
outb(PIC2_DATA, 0x01);
outb(PIC1_DATA, 0xFE);
outb(PIC2_DATA, 0xFF);
(void)inb(PIC1_DATA);
}
0xFE 是二进制 1111 1110:bit0 是 0,IRQ0 放开;其它位是 1,继续屏蔽。
PIT 挂在 IRQ0 上,按 100Hz 产生时钟:
static void pit_init(void)
{
u16 divisor = (u16)PIT_DIVISOR;
outb(PIT_CMD, 0x36);
outb(PIT_CH0, (u8)(divisor & 0xFFu));
outb(PIT_CH0, (u8)(divisor >> 8));
}
PIT_DIVISOR 是 1193182 / 100,大约 11931。每次时钟进来,tick 加一,调度器就有机会检查当前任务是不是该让位。
中断处理完还要发 EOI:
void interrupt_eoi(void)
{
outb(PIC1_CMD, 0x20);
}
不发,下一次同等级中断就进不来,时钟会停,调度也会停。第一次看到 PIT TICKS 只跳一下,往往不是 PIT 停了,是 EOI 没发:主 PIC 还在等这一声确认,第二次 IRQ0 被挡在门外。
九、任务是一套栈,不是函数
时钟来了,还没有任务接住它。任务有自己的入口、自己的栈、自己的状态。切换任务时不能只调一个函数:把当前任务的栈指针保存起来,换成下一个任务的栈指针,再从中断返回。
任务结构里,最关键的是 ctx.esp。
#define TASK_MAX 6
#define TASK_NAME_MAX 15
#define CTX_FRAME_SLOTS 12
#define STACK_MAGIC 0xA5A5A5A5u
#define WEIGHT_QUANTUM 64u
#define PID_MAX 31
enum task_state {
TASK_UNUSED = 0,
TASK_READY = 1,
TASK_RUNNING = 2,
TASK_BLOCKED = 3,
TASK_ZOMBIE = 4
};
struct irq_frame {
u32 eax, ebx, ecx, edx, esi, edi, ebp;
u32 vector, err, eip, cs, eflags;
};
struct context {
u32 esp;
};
struct task_struct {
int pid;
int state;
int priority;
char comm[TASK_NAME_MAX + 1];
void (*entry)(void);
u32 stack_base;
u32 stack_top;
u32 switches;
u32 cpu_ticks;
u64 vruntime;
struct context ctx;
};
任务槽是一个静态数组,current_task 指向正在跑的那个。task_create() 之前有三件小事:按 priority 算权重,用 pid_map 分配 PID,把任务槽清零。少一件,任务槽还没收拾干净就发布 READY,调度器可能选中一个半成品。
task_create() 的关键在栈:stack_base = stack_top - AEVUM_TASK_STACK_SIZE 算栈底,sp = (u32 *)(stack_top - CTX_FRAME_SLOTS * 4) 把栈顶往下让出 12 个槽,sp[9] = (u32)entry 把入口写进 eip 槽。
sp = (u32 *)(stack_top - CTX_FRAME_SLOTS * 4);
for (i = 0; i < CTX_FRAME_SLOTS; i++) sp[i] = 0;
sp[9] = (u32)entry; /* eip */
sp[10] = 0x08; /* cs */
sp[11] = 0x202; /* eflags,IF=1 */
task->ctx.esp = (u32)sp;
最后一步是发布 READY,而且要关中断写。早一步发布,PIT 可能在 task_create 中途抢走一个 ctx.esp 还没填好的任务。
帧布局是:
eax ebx ecx edx esi edi ebp vector err eip cs eflags
sp[9] 是 eip,指向任务入口;sp[10] 是 cs=0x08;sp[11] 是 eflags=0x202,把 IF 打开。第一次 iret 的时候,CPU 就按这帧进入任务。
第一次 iret 最容易错在帧槽位。少压一个槽,CPU 就把 cs 当成 eip,跳进一个不是入口的地址,QEMU 直接重启,连打印都没有。
void task_start(struct task_struct *first)
{
start_target = first;
sched_reason = SCHED_START;
sched_failed = 0;
__asm__ __volatile__("int $0x40");
for (;;) __asm__ __volatile__("cli; hlt");
}
task_start() 不直接跳,它设 SCHED_START,然后 int 0x40。调度器选中第一个任务,返回它的 ctx.esp;loader.asm 恢复这帧,iret 进入任务。这样 “启动第一个任务” 和 “时钟切任务” 走的是同一条恢复路径,不会有两套逻辑。
任务状态现在跑通了这几条边:
UNUSED -> READY -> RUNNING -> BLOCKED -> READY
|
-> ZOMBIE -> UNUSED
task_create() 把任务放进 READY;调度器选中它,变成 RUNNING;时间片到了或者主动让出,回 READY;等事件,进 BLOCKED;任务退出,进 ZOMBIE,下一次调度回收 PID。
十、调度器:谁最小,谁先跑
时钟进来了,调度还没有。唯一入口是 task_schedule_irq(),IRQ0 和 int 0x40 都走它。
调度器第一次跑,最容易看见的是 “只有一个任务在跑”。task_pick_next 每次都选回当前任务,另外两个一直停在 READY;屏幕上的 sw 不涨,PIT TICKS 却一直涨。时钟进来了,调度器也进来了,但没人被换上去。
task_schedule_irq 的关键在三次交接:prev->ctx.esp = (u32)frame 保存当前栈顶,next = task_pick_next(prev) 选下一个,return next->ctx.esp 把新栈顶交给汇编。
u32 task_schedule_irq(struct irq_frame *frame)
{
struct task_struct *prev = current_task;
struct task_struct *next;
u32 reason = sched_reason;
if (!prev || !frame) {
for (;;) __asm__ __volatile__("cli; hlt");
}
if (frame->vector == 0x20) {
interrupt_eoi();
reason = SCHED_TICK;
if (prev->state == TASK_RUNNING) {
prev->cpu_ticks++;
prev->vruntime += WEIGHT_QUANTUM / task_weight(prev);
}
}
prev->ctx.esp = (u32)frame;
sched_failed = 0;
if (reason == SCHED_START) {
next = start_target;
if (!next || next->state != TASK_READY) {
sched_failed = 1;
for (;;) __asm__ __volatile__("cli; hlt");
}
next->state = TASK_RUNNING;
current_task = next;
task_note_switch(next);
sched_reason = SCHED_YIELD;
return next->ctx.esp;
}
if (prev->state == TASK_RUNNING) {
if (reason == SCHED_EXIT)
prev->state = TASK_ZOMBIE;
else if (reason == SCHED_BLOCK)
prev->state = TASK_BLOCKED;
else
prev->state = TASK_READY;
}
task_reap();
next = task_pick_next(prev);
if (!next) {
if (reason == SCHED_EXIT)
for (;;) __asm__ __volatile__("cli; hlt");
if (reason == SCHED_BLOCK) {
prev->state = TASK_RUNNING;
sched_failed = 1;
} else {
prev->state = TASK_RUNNING;
}
next = prev;
}
if (next != prev) {
prev->switches++;
next->state = TASK_RUNNING;
if (reason == SCHED_TICK) preempt_total++;
task_note_switch(next);
} else {
next->state = TASK_RUNNING;
}
current_task = next;
sched_reason = SCHED_YIELD;
return next->ctx.esp;
}
WEIGHT_QUANTUM 是 64,task_weight() 返回 priority + 1。控制优先级 3,权重 4;渲染 2,权重 3;空闲 0,权重 1。每个 tick 给正在跑的任务加 64 / weight,权重高的加得慢,选 vruntime 最小的跑。
task_pick_next() 只选 READY,同值从 prev 后面的槽位轮转,避免固定顺序把低优先级任务饿死。
static struct task_struct *task_pick_next(struct task_struct *prev)
{
struct task_struct *best = 0;
u64 best_v = 0;
int start = 0;
int i;
for (i = 0; i < TASK_MAX; i++) {
if (&tasks[i] == prev) {
start = i + 1;
break;
}
}
for (i = 0; i < TASK_MAX; i++) {
int idx = (start + i) % TASK_MAX;
struct task_struct *t = &tasks[idx];
if (t->state != TASK_READY) continue;
if (!best || t->vruntime < best_v) {
best = t;
best_v = t->vruntime;
}
}
return best;
}
切换时,prev->ctx.esp = (u32)frame,把当前栈顶存进任务结构;返回 next->ctx.esp,loader.asm 把 esp 换过去,弹出寄存器,iret。这就是上下文切换的全部形状。
preempt_total 只在 IRQ0 真正切走时加一;switch_total 连主动 task_yield() 也算。所以屏幕上的 px 和 sw 不是一回事。
抢占决斗就是两个不调用 task_yield() 的 CPU 密集型循环,靠 PIT 强切。如果时钟不抢,先跑的那个会把另一个彻底饿死。

十一、任务还得能等
调度转了,阻塞还没有。分完时间还不够,任务得能停下来等一个事件。
task_block() 不只改状态,它走 task_set_current_state(TASK_BLOCKED),设 SCHED_BLOCK,然后 int 0x40。调度器把当前任务标成 BLOCKED,切到下一个 READY;如果没有别的任务可跑,它会恢复当前任务为 RUNNING 并返回错误,不会把 CPU 空在那里。
第一次让空闲任务阻塞,屏幕会停在 BLOCKED: idle waiting task_wake(),PIT TICKS 还在涨。CPU 没停,但那个任务不动了;没有另一个任务调 task_wake,它会一直等。
u32 task_set_current_state(int state)
{
struct task_struct *prev = current_task;
if (!prev || prev->state != TASK_RUNNING) return ERR_TASK_BAD_STATE;
if (state == TASK_RUNNING) return 0;
if (state == TASK_READY) {
sched_reason = SCHED_YIELD;
} else if (state == TASK_BLOCKED) {
sched_reason = SCHED_BLOCK;
} else if (state == TASK_ZOMBIE) {
sched_reason = SCHED_EXIT;
} else {
return ERR_TASK_BAD_STATE;
}
sched_failed = 0;
__asm__ __volatile__("int $0x40");
if (state == TASK_ZOMBIE)
for (;;) __asm__ __volatile__("cli; hlt");
return sched_failed ? ERR_TASK_BAD_STATE : 0;
}
u32 task_block(void)
{
return task_set_current_state(TASK_BLOCKED);
}
u32 task_yield(void)
{
return task_set_current_state(TASK_READY);
}
唤醒是另一个任务调 task_wake(pid):
u32 task_wake(int pid)
{
int i;
for (i = 0; i < TASK_MAX; i++) {
if (tasks[i].pid == pid && tasks[i].state == TASK_BLOCKED) {
tasks[i].state = TASK_READY;
return 0;
}
}
return ERR_TASK_BAD_STATE;
}
它只把 BLOCKED 改成 READY,不立刻切过去;下一次调度,这个任务才会被选中。
现在的阻塞没有超时,也没有 sleep;task_wake() 必须由另一个任务显式调用。超时和 sleep 还没进来。

十二、三个任务:控制、渲染、空闲
任务能等了,应用还没有。任务系统立住以后,机械臂才有地方挂。arm_app_init() 创建三个常驻任务:
u32 arm_app_init(void)
{
u32 rc;
app_dep_code = 0;
arm_control_init();
arm_render_init();
rc = task_create(3, "control", proc_control, AEVUM_STACK_P1, &p_control);
if (rc) {
app_dep_code = rc;
return ERR_ARM_APP_TASK_CREATE;
}
rc = task_create(2, "render", proc_render, AEVUM_STACK_P2, &p_render);
if (rc) {
app_dep_code = rc;
return ERR_ARM_APP_TASK_CREATE;
}
rc = task_create(0, "idle", proc_idle, AEVUM_STACK_IDLE, &p_idle);
if (rc) {
app_dep_code = rc;
return ERR_ARM_APP_TASK_CREATE;
}
return 0;
}
控制任务每轮算一次机械臂,然后主动让出:
static void proc_control(void)
{
for (;;) {
arm_control_step();
if (task_yield()) {
struct aevum_error e = app_err_template;
e.code = ERR_ARM_APP_SWITCH;
e.field = "task_yield(control)";
aevum_fail(&e);
}
}
}
渲染任务读一份 arm_status 快照,画到 VGA 文本屏,再让出:
static void proc_render(void)
{
for (;;) {
struct arm_status status;
arm_control_status(&status);
arm_render_frame(&status);
if (idle_blocked)
vga_text(2, 2, "BLOCKED: idle waiting task_wake()", 0x09);
vga_flush();
if (task_yield()) {
struct aevum_error e = app_err_template;
e.code = ERR_ARM_APP_SWITCH;
e.field = "task_yield(render)";
aevum_fail(&e);
}
}
}
空闲任务在没人可跑的时候占着 CPU;它也可以被阻塞:
static void proc_idle(void)
{
idle_pid = task_current_pid();
for (;;) {
if (idle_block_req) {
idle_block_req = 0;
idle_blocked = 1;
if (task_block()) idle_blocked = 0;
idle_blocked = 0;
}
if (task_yield()) {
struct aevum_error e = app_err_template;
e.code = ERR_ARM_APP_SWITCH;
e.field = "task_yield(idle)";
aevum_fail(&e);
}
}
}
屏幕上出现 BLOCKED: idle waiting task_wake() 的时候,空闲任务已经进了 BLOCKED;另一个任务调用 task_wake(idle_pid),它回到 READY,下一次调度再回来。
机械臂的运动学是纯函数,控制任务持有 q/dq/target 这些状态,渲染只读快照,不直接碰控制器的私有变量。控制算完一拍,渲染画一帧,空闲兜底;三个任务都挂在同一套调度器上,不是三个死循环各跑各的。

控制权重 4、渲染 3、空闲 1,CPU 份额大约 50% / 38% / 12%。这个比例没写死在代码里,是 vruntime 在每个 tick 累出来的结果。

十三、镜像怎么装,地址怎么让
三个任务转起来了,镜像还得装得下。这张内存表得先立住:
0x1000..0x64A0 内核镜像和 BSS
0x7000..0xE000 任务栈区
0x8000 控制任务栈顶
0x9000 渲染任务栈顶
0xA000 空闲任务栈顶
0xB000 C 代码栈
0x10000 页目录
0x11000 页表
0x12000..0x127FF IDT
0x12800 GDT 副本
0xB8000 VGA 文本显存
这张表落在 config/memory.h 里,每个地址都有名字,其它模块只读。
这张表里有两个边界最容易错:任务栈区从 0x7000 起,所以 GDT 原址 0x7c97 会被控制任务栈盖住;任务栈上界到 0xE000,再往上 0x10000 就是页目录,栈再多一页就会把页表写坏。
镜像是这样装出来的:
boot.asm -> boot.bin(512 字节,放在扇区 0)
loader.asm + C -> kernel.elf -> kernel.bin(放在扇区 1,最多 40 扇区)
boot.bin + kernel.bin -> disk.img
qemu-system-i386 -drive format=raw,file=disk.img
Makefile 里最关键的是这几行:
CFLAGS = -m32 -ffreestanding -c -O2 -fno-pic -fno-pie \
-fno-stack-protector -fno-asynchronous-unwind-tables \
-Iinclude -I.
kernel.elf: $(OBJS) $(BUILD)/loader.o $(LDSCRIPT)
$(LD) -m elf_i386 -T $(LDSCRIPT) $(BUILD)/loader.o $(OBJS) -o kernel.elf
kernel.bin: kernel.elf
objcopy -O binary kernel.elf kernel.bin
链接脚本决定 0x1000 这个入口和 BSS 的边界:
ENTRY(start);
SECTIONS {
. = 0x1000;
.text : {
*(.boot)
*(.text)
*(.text.*)
}
.rodata : {
*(.rodata)
*(.rodata.*)
}
.eh_frame : {
*(.eh_frame)
}
.data : {
*(.data)
*(.data.*)
}
.bss : {
. = ALIGN(4);
__bss_start = .;
*(COMMON)
*(.bss)
*(.bss.*)
. = ALIGN(4);
__bss_end = .;
}
}
__bss_start、__bss_end 是链接器写进二进制的两个符号,loader.asm 用它们算清零范围。kernel.bin 现在 20,276 字节,上限是 40 个扇区,也就是 20,480 字节;再大,boot.asm 就读不完了。多 204 字节,boot.asm 还是只读 40 个扇区;内核尾部留在盘上,内存里是 0。它不会报错,跑到尾部取指就进一片 0。
机器上要有 nasm、支持 -m32 的 gcc、ld、make、qemu-system-i386。构建是 make clean && make all,运行是 make run。
十四、跑起来的样子
屏幕亮起来以后,先看到的不是机械臂,是文本模式的一屏状态。
CPU 统计页上,三个任务大约 50% / 38% / 12%,PIT TICKS 一直涨。这个比例不是写死的,是每个 tick 的 vruntime 累出来的。

机械臂主画面里,@ 是末端、O 是肘、* 是腕、o 是目标、. 是末端轨迹、# 是基座。控制任务算一拍,渲染任务画一帧,画面跟着帧号往前走。

空闲任务被阻塞时,左上角会出现 BLOCKED: idle waiting task_wake()。帧还在走,PIT TICKS 还在涨,但空闲任务不动了。

抢占决斗是两个不主动让出的循环,A/B 两侧的 STEP 同时增长。时钟一次次切进去,保存一边的栈,换另一边的栈;两边都没有把 CPU 霸住。

屏幕上的 px 和 sw 不是一回事:px 只算 IRQ0 真正切走的次数,sw 连主动 task_yield() 也算。两个数一起涨,才说明时钟和主动让出都在工作。
十五、走到这里
再把这条路径走一遍:
实模式 -> 保护模式 -> 分页 -> C 运行环境 -> 中断 -> 任务 -> 调度 -> 阻塞 -> 应用
每一步都卡着下一步:GDT 让 CPU 能进保护模式;远跳让 CS 真正切到 32 位代码段;页表让地址可控;BSS 和栈让 C 能跑;IDT/PIC/PIT 让时钟能进来;任务栈和中断帧让任务能被恢复;调度器让多个任务分 CPU;BLOCKED/task_wake 让任务能等;三个任务让机械臂有地方挂。
这套内核现在能自己进 32 位、开页表、接时钟、切任务、阻塞、唤醒,能把机械臂和抢占决斗跑起来。它还不是完整系统:异常门还没填,阻塞没有超时,分页只是 0 到 4MB 的恒等映射。但底层件已经立住了。
机器能画机械臂,三个任务能切。不是代码多,是每一层都接住了。少一层,屏幕黑,机械臂跳。
DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐


所有评论(0)