机器人制造师(三):从 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 还没进来。

B 任务阻塞,空闲任务在跑

十二、三个任务:控制、渲染、空闲

任务能等了,应用还没有。任务系统立住以后,机械臂才有地方挂。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 累出来的结果。

三个任务在分 CPU

十三、镜像怎么装,地址怎么让

三个任务转起来了,镜像还得装得下。这张内存表得先立住:

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 累出来的。

三个任务在分 CPU

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

机械臂主画面

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

B 任务阻塞,空闲任务在跑

抢占决斗是两个不主动让出的循环,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 的恒等映射。但底层件已经立住了。

机器能画机械臂,三个任务能切。不是代码多,是每一层都接住了。少一层,屏幕黑,机械臂跳。

Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐