简介：本资源是一份面向高校计算机专业本科生的操作系统原理课程设计报告，聚焦裸机环境下保护模式的底层实现与多任务调度机制验证。报告完整呈现了在无操作系统干预的实模式启动后，通过MBR加载、保护模式切换、段/页机制配置、时钟中断设置、任务创建与优先数调度等核心环节，实现四个不同优先级任务（16/10/8/6）在屏幕同位置轮显字符串的全过程，直观体现优先级与执行时长的正相关性。资源为单个405KB的Word文档（.doc），涵盖课设目的、系统设计思路、Docker容器化实验环境搭建（含Dockerfile与docker-compose配置）、核心技术难点分析（内存布局、BOOT初始化、任务切换等7大模块）、运行测试及心得总结，目录结构严谨，理论推导与代码逻辑紧密结合。目前已有70人学习下载，适合深入理解x86保护模式、动手实践多任务调度算法、开展操作系统底层开发训练的学习者。
1. 裸机保护模式下的多任务：不是跑个 demo 就算成功，而是让 CPU 真正听你指挥
“在裸机保护模式下编写多任务并演示页机制和优先数调度机制”——这行标题背后，不是一份交差的课设报告，而是一次对 x86 架构底层控制权的亲手接管。它意味着你绕过所有操作系统内核、不依赖任何 bootloader（如 GRUB）的抽象层，从实模式跳转后，亲手初始化 GDT、IDT、CR0/CR3 寄存器，让 CPU 进入保护模式；接着在无内存管理单元（MMU）驱动、无 libc、无系统调用的前提下，用纯汇编+少量 C 实现任务切换、页表映射、中断响应与基于优先级的轮转调度。这不是写个线程池或 fork 几个进程，而是让每个“任务”拥有独立的 TSS、自己的 LDT、被映射到不同虚拟地址空间的代码段与数据段，并能被时钟中断精准抢占。适合某高校操作系统原理课程高阶实践者、嵌入式底层开发初学者，以及想撕开 Linux 内核调度器黑匣子的硬核玩家。如果你只希望“跑通一个带 printf 的多任务 demo”，这条路会反复让你怀疑人生；但若你渴望看清“进程切换时寄存器怎么保存”“缺页异常到底发生在哪条指令之后”“为什么优先数调度必须配合时间片重载”，那这就是最扎实的入口。
2. 从实模式跳转到保护模式：GDT、CR0 与 IDT 的三步落地
要让 CPU 听你指挥，第一步是让它“认出你”。x86 CPU 上电默认处于实模式（16 位段寻址，最大 1MB 地址空间），而保护模式（32 位平坦模型或分段+分页）才是现代多任务的基础。跳转不是一条指令的事，而是三件套协同生效：全局描述符表（GDT）、控制寄存器 CR0 的 PE 位、中断描述符表（IDT）。缺一不可，错一个就卡死或重启。
2.1 手写 GDT：段描述符结构与加载顺序不能颠倒
GDT 是保护模式的“身份认证中心”，它定义了代码段（CS）、数据段（DS）、堆栈段（SS）甚至任务状态段（TSS）的基址、界限和权限。每个描述符 8 字节，按固定格式排列。我们至少需要 4 个描述符：空描述符（索引 0，强制存在）、代码段（DPL=0，可执行）、数据段（DPL=0，可读写）、TSS 段（用于硬件任务切换，本项目中我们采用软件任务切换，但仍需预留）。关键点在于：GDT 必须连续存放于物理内存，且其首地址与长度需通过lgdt指令精确加载。
; gdt.asm —— GDT 定义与加载 gdt_start: dq 0x0 ; null descriptor (index 0) code_seg: dw 0xFFFF ; limit low dw 0x0 ; base low db 0x0 ; base middle db 10011010b ; access byte: present, DPL=0, code, readable, conforming=0, accessed=0 db 11001111b ; flags+limit high: 32-bit, granularity=1 (4KB), limit high=0xF db 0x0 ; base high data_seg: dw 0xFFFF ; limit low dw 0x0 ; base low db 0x0 ; base middle db 10010010b ; access: present, DPL=0, data, writable, expand-down=0, accessed=0 db 11001111b ; flags+limit high db 0x0 ; base high tss_seg: dw tss_end - tss_start - 1 ; limit low (TSS size) dw tss_start & 0xFFFF ; base low db tss_start >> 16 ; base middle db 10001001b ; access: present, DPL=0, TSS (busy=0 initially) db 00000000b ; flags (no granularity for TSS) db tss_start >> 24 ; base high gdt_end: gdt_descriptor: dw gdt_end - gdt_start - 1 ; size of GDT (16-bit) dd gdt_start ; base address (32-bit) ; 加载 GDT load_gdt: lgdt [gdt_descriptor] mov ax, 0x08 ; code segment selector = index 1 * 8 + TI=0 + RPL=0 mov ds, ax mov es, ax mov fs, ax mov gs, ax mov ss, ax ret逻辑说明：
gdt_descriptor是lgdt指令所需的结构体，前 2 字节为 GDT 长度（limit），后 4 字节为起始地址（base）。dw gdt_end - gdt_start - 1计算的是字节数减 1（因为 limit 是 inclusive）。mov ax, 0x08中的0x08是代码段选择子：索引 1（第 2 个描述符），TI=0（GDT），RPL=0（特权级 0）。注意：数据段选择子应为0x10（索引 2），TSS 选择子为0x18（索引 3），这些值必须与 GDT 中描述符顺序严格对应，否则后续jmp切换时 CPU 会因找不到有效段而 triple fault。
2.2 开启 PE 位：CR0 的第 0 位是开关，但必须先关中断
设置好 GDT 后，CPU 仍处于实模式。真正切换的指令只有一条：mov cr0, eax，其中eax的 bit0（PE 位）置 1。但这里有个致命陷阱：在写 CR0 前，必须用cli关闭中断。原因在于，一旦 PE 置 1，CPU 立即按保护模式规则解析后续指令，而此时 IDT 尚未初始化，任何中断（包括键盘、时钟）都会触发 #GP（通用保护异常），导致系统崩溃。因此标准流程是：
cli—— 立即关闭所有可屏蔽中断；lgdt [gdt_descriptor]—— 加载 GDT；mov eax, cr0→or eax, 1→mov cr0, eax—— 设置 PE 位；jmp 0x08:flush_cs—— 强制刷新 CS 寄存器（远跳转），使 CPU 开始用新段描述符取指；flush_cs:标签后，才可安全启用 IDT 和开中断。
; enable_protected_mode.asm cli ; 关中断！血泪经验：漏掉这句，90% 的初学者第一次跳转必死 lgdt [gdt_descriptor] mov eax, cr0 or eax, 1 ; set PE bit mov cr0, eax jmp 0x08:flush_cs ; far jump to load CS with new descriptor flush_cs: mov ax, 0x10 ; data segment selector (index 2) mov ds, ax mov es, ax mov fs, ax mov gs, ax mov ss, ax mov esp, 0x7C00 ; 初始化栈顶（实模式下 BIOS 加载位置） sti ; 此时才可开中断 ret参数说明：
esp初始化为0x7C00是因为本项目通常以软盘镜像或 QEMU-kernel方式启动，BIOS 将引导扇区加载至此。若使用其他加载方式（如 GRUB multiboot），需根据实际入口调整栈指针。sti必须在flush_cs标签之后，确保 CS 已更新，否则开中断瞬间就会 fault。
2.3 IDT 初始化：中断向量表不是数组，而是门描述符数组
进入保护模式后，中断不再由实模式的 IVT（中断向量表，1KB，每项 4 字节）处理，而是由 IDT（中断描述符表）接管。IDT 中每一项是 8 字节的“门描述符”（Gate Descriptor），分为任务门、中断门、陷阱门。我们使用中断门（Interrupt Gate），因为它在进入中断服务例程（ISR）时自动清 IF 位（禁用中断），防止嵌套中断干扰调度逻辑。
IDT 的初始化与 GDT 类似，需定义描述符数组，并用lidt加载。关键区别在于：每个门描述符的偏移地址（offset）必须是 32 位线性地址，且 ISR 必须用iret返回（而非ret）。由于我们尚未启用分页，线性地址 = 物理地址，因此 ISR 地址可直接取标号。
; idt.asm idt_start: ; 0x00: Divide Error dw isr0_handler_end - isr0_handler_start ; offset low dw 0x08 ; selector (code_seg) dw 0x8E00 ; type=14 (interrupt gate), DPL=0, P=1 dw isr0_handler_start >> 16 ; offset high ; 0x20: Programmable Interrupt Timer (PIT) —— 我们的调度核心 dw isr20_handler_end - isr20_handler_start dw 0x08 dw 0x8E00 dw isr20_handler_start >> 16 ; ... 其他中断向量（0x01~0x1F, 0x21~0xFF）可填空或指向统一 panic handler idt_end: idt_descriptor: dw idt_end - idt_start - 1 dd idt_start ; 加载 IDT load_idt: lidt [idt_descriptor] ret ; 示例 ISR：时钟中断（IRQ0，对应 IDT[0x20]） isr20_handler_start: pusha ; 保存所有通用寄存器（关键！调度依赖此） push ds push es push fs push gs mov ax, 0x10 mov ds, ax mov es, ax ; 此处插入调度器主逻辑（见第 4 章） pop gs pop fs pop es pop ds popa iret ; 必须用 iret！ret 会导致栈错乱 isr20_handler_end:逻辑说明：
pusha/popa是保护模式下保存/恢复任务上下文的基石。iret不仅弹出 EIP，还弹出 CS 和 EFLAGS，从而正确恢复中断前的状态。dw 0x8E00中0x8E表示：bit15=1（Present），bit14-13=11（Descriptor Privilege Level=0），bit12=0（Storage Segment=0），bit11-8=1110（Gate Type=Interrupt Gate），00是保留位。错误示范：若此处误写为0x8F00（Trap Gate），则 IF 不会被清，可能导致时钟中断嵌套，栈溢出。
3. 多任务框架：TSS、任务切换与页表的协同设计
有了保护模式基础，下一步是让多个“任务”共存。x86 提供两种任务切换方式：硬件任务切换（通过jmp far或call far切换到 TSS 描述符）和软件任务切换（手动保存/恢复寄存器）。本项目采用软件任务切换，因其更可控、更易调试，且能与页机制、优先数调度深度耦合。核心在于：每个任务拥有独立的 TSS 结构（用于记录当前状态）、独立的页目录/页表（实现地址空间隔离）、以及一个可被调度器读取的优先数字段。
3.1 任务控制块（TCB）设计：不只是寄存器快照，更是调度元数据
在 C 层，我们定义一个task_t结构体，作为每个任务的“身份证”和“行李箱”：
// task.h #define MAX_TASKS 4 #define TASK_STACK_SIZE 0x1000 typedef struct { uint32_t ebp; // 任务栈底（用于切换时恢复） uint32_t esp; // 任务栈顶（切换时加载到 ESP） uint32_t eip; // 下一条指令地址（切换后从此执行） uint32_t cr3; // 页目录基址（关键！实现地址空间隔离） uint32_t priority; // 优先数（数值越小，优先级越高） uint32_t time_slice; // 当前剩余时间片（毫秒） uint32_t state; // TASK_RUNNING / TASK_BLOCKED / TASK_SLEEPING uint8_t stack[TASK_STACK_SIZE]; // 任务私有栈 } task_t; extern task_t tasks[MAX_TASKS]; extern task_t* current_task; extern uint32_t task_count;参数说明：
cr3是页机制的核心寄存器，保存当前页目录物理地址。每个任务切换时，必须mov cr3, [task->cr3]并执行invlpg（或直接mov cr3, cr3触发 TLB flush），才能让 CPU 使用该任务专属的页表。priority是整型，范围建议 0~31（0 最高），避免负数引发符号扩展问题。time_slice初始值设为 100ms，由时钟中断递减，归零则触发调度。
3.2 页机制落地：四级页表？不，我们用经典的两级页表（Page Directory + Page Table）
x86 32 位保护模式下，虚拟地址经两级查表转换为物理地址：高 10 位索引页目录（PD），中间 10 位索引页表（PT），低 12 位为页内偏移。本项目不启用 PAE，故使用标准 4KB 页。关键点在于：每个任务的页目录必须独立，且 PD 中第 0 项（对应虚拟地址 0x00000000~0x003FFFFF）必须映射到该任务的私有页表；而内核代码/数据（如 GDT、IDT、内核栈）需映射到所有任务的页表中相同虚拟地址（如 0xC0000000 以上），实现“内核共享、用户隔离”。
// mm.c —— 页表初始化 void init_page_directory(task_t* task) { // 分配一页作为页目录（PD） uint32_t* pd = (uint32_t*)alloc_page(); memset(pd, 0, 0x1000); // 映射内核空间（0xC0000000 ~ 0xFFFFFFFF）：所有任务共享 for (int i = 0xC00; i < 0x400; i++) { // 0xC00 对应 0xC0000000 pd[i] = (uint32_t)alloc_page() | 0x03; // P=1, RW=1, US=0 (supervisor) } // 映射任务私有空间（0x00000000 ~ 0xBFFFFFFF）：每个任务独占 uint32_t* pt = (uint32_t*)alloc_page(); memset(pt, 0, 0x1000); for (int i = 0; i < 0xC00; i++) { // 0xC00 项，覆盖 0x00000000~0xBFFFFFFF pt[i] = (uint32_t)alloc_page() | 0x03; // 每页 4KB，RW=1, US=1 (user) } pd[0] = (uint32_t)pt | 0x03; // PD[0] 指向该任务的页表 task->cr3 = (uint32_t)pd; // 保存 PD 物理地址 } // 切换任务时激活页表 void switch_page_directory(uint32_t cr3) { asm volatile("mov %0, %%cr3" :: "r"(cr3) : "cr3"); asm volatile("mov %%cr3, %%cr3" ::: "cr3"); // TLB flush }逻辑说明：
alloc_page()是一个简单的物理内存分配器（如 bitmap 管理），返回未使用的 4KB 物理页地址。pd[i] = ... | 0x03中0x03表示 Present=1, ReadWrite=1, UserSupervisor=0（内核）或 1（用户）。关键技巧：内核空间映射在 PD 的高 256 项（0xC00~0x3FF），这样无论哪个任务运行，访问0xC0100000（内核代码）都命中同一物理页；而用户空间映射在 PD[0] 指向的页表中，各任务页表内容不同，实现隔离。mov cr3, cr3是 x86 推荐的 TLB 刷新方式，比invlpg更高效。
3.3 任务创建与上下文初始化：栈帧布局决定切换成败
创建任务不是malloc一个结构体那么简单，而是要精心构造其初始栈帧，使其iret后能正确进入 C 函数。x86 中断返回时，栈顶必须是EIP, CS, EFLAGS, ESP, SS的顺序（由pusha/push指令保证）。因此，task_create()的核心是：在任务栈顶布置这个“假中断帧”，让首次切换时iret自动弹出并跳转。
// task.c void task_create(void (*entry)(void), uint32_t priority) { if (task_count >= MAX_TASKS) return; task_t* t = &tasks[task_count++]; memset(t, 0, sizeof(task_t)); t->priority = priority; t->time_slice = 100; // 分配并初始化页表 init_page_directory(t); // 初始化栈：构造“假中断帧” uint32_t* stack_top = (uint32_t*)(t->stack + TASK_STACK_SIZE); stack_top -= 5; // 为 EIP, CS, EFLAGS, ESP, SS 预留 5 个 uint32_t stack_top[0] = (uint32_t)entry; // EIP stack_top[1] = 0x08; // CS (code_seg selector) stack_top[2] = 0x202; // EFLAGS (IF=1, IOPL=0) stack_top[3] = (uint32_t)(t->stack + TASK_STACK_SIZE - 16); // ESP for task's own stack stack_top[4] = 0x10; // SS (data_seg selector) t->esp = (uint32_t)stack_top; t->eip = (uint32_t)task_entry_stub; // 切换后首条指令是 stub，它会 pop 并 call entry } // 汇编 stub：清理栈帧，调用 C 入口 ; task_stub.asm task_entry_stub: pop ebp pop ebx pop ecx pop edx pop esi pop edi pop eax call eax ; call the real entry function jmp task_exit ; never returns参数说明：
EFLAGS=0x202是标准值（bit9=IF=1，允许中断；bit12-13=IOPL=0，禁止用户态 I/O 指令）。stack_top[3]是任务自身栈顶，必须低于stack_top（即t->stack + TASK_STACK_SIZE - 16），否则pusha会溢出。task_entry_stub的作用是：在iret恢复后，栈上残留的是entry函数地址，pop eax取出它，call eax跳转，完美衔接 C 世界。玄学点：若entry函数内有局部变量或调用printf（需栈空间），TASK_STACK_SIZE=0x1000（4KB）是底线，小于 2KB 极易栈溢出。
4. 优先数调度机制：不是简单排序，而是抢占式时间片轮转
多任务若无调度，只是多个函数顺序执行。本项目要求“优先数调度”，即任务按priority数值升序排列（0 最高），但必须结合时间片（time slice）实现抢占：高优先级任务就绪时立即抢占，同优先级任务则轮转。核心调度器位于时钟中断 ISR 中，它不主动“启动”任务，而是决定“下一个该运行谁”。
4.1 调度器主逻辑：扫描就绪队列，选最高优+非阻塞任务
调度器在isr20_handler中被调用。它遍历所有tasks[]，筛选出state == TASK_RUNNING且priority最小的任务。若当前任务时间片耗尽（time_slice == 0）或有更高优任务就绪，则触发切换。
; 在 isr20_handler 中调用 call scheduler ; scheduler.asm scheduler: pusha push ds push es mov ax, 0x10 mov ds, ax mov es, ax ; 查找最高优先级就绪任务 mov ebx, 0 ; current best index mov ecx, 0xFFFFFFFF ; best priority (init to max) mov esi, 0 ; task index counter find_best: cmp esi, [task_count] jge found ; all tasks scanned mov edi, esi shl edi, 4 ; edi = esi * sizeof(task_t) mov eax, [tasks + edi + 12] ; load task[i].priority cmp eax, [tasks + ebx*4 + 12] ; compare with current best jae next_task ; if >=, skip (not better) ; check state == TASK_RUNNING cmp dword [tasks + edi + 20], 0 ; task[i].state == 0? jne next_task mov ecx, eax ; update best priority mov ebx, esi ; update best index next_task: inc esi jmp find_best found: cmp ebx, [current_task_index] ; is best same as current? je no_switch ; save current task context to its TCB mov esi, [current_task_index] shl esi, 4 mov [tasks + esi + 0], ebp ; save ebp mov [tasks + esi + 4], esp ; save esp mov [tasks + esi + 8], eip ; save eip (tricky: need to get return addr) ; load new task context mov [current_task_index], ebx mov esi, ebx shl esi, 4 mov ebp, [tasks + esi + 0] mov esp, [tasks + esi + 4] mov eip, [tasks + esi + 8] ; switch page directory mov eax, [tasks + esi + 16] ; load cr3 call switch_page_directory no_switch: pop es pop ds popa ret逻辑说明：
eip的保存是难点。在 ISR 中，eip指向的是iret指令本身，而非任务下一条指令。因此，更健壮的做法是在task_entry_stub中，call eax前将eip（即entry地址）显式存入task->eip。此处为简化，假设task->eip已由task_create()正确初始化。switch_page_directory是 C 函数，通过call调用，它内部执行mov cr3, %0汇编。
4.2 时间片管理：时钟中断频率与调度粒度的平衡
时钟中断（IRQ0）由可编程定时器 PIT（Programmable Interval Timer）产生，默认频率 18.2Hz（约 55ms）。这对调度来说太慢，无法体现“实时性”。我们将其重编程为 100Hz（10ms），使时间片最小单位为 10ms，time_slice以 10ms 为单位递减。
; pit_init.asm —— 重编程 PIT 为 100Hz pit_init: mov al, 0x36 ; command: channel 0, LSB/MSB, rate generator out 0x43, al mov ax, 11932 ; divisor = 1193180 / 100 ≈ 11932 out 0x40, al ; LSB mov al, ah out 0x40, al ; MSB ret参数说明：PIT 基频 1.19318 MHz，目标频率
f = 1193180 / divisor。divisor = 1193180 / 100 = 11931.8 ≈ 11932。out 0x43, 0x36表示：选择通道 0（IRQ0），写入方式为 LSB then MSB，工作模式为 3（方波发生器）。踩坑预警：若 divisor 计算错误（如用 1000000 代替 1193180），实际中断频率会偏差 20%，导致时间片严重不准。
4.3 优先数调度的边界：如何处理“饥饿”与“抢占延迟”
纯优先数调度（Priority Scheduling）有两大缺陷：低优先级任务可能永远得不到 CPU（饥饿），以及高优先级任务频繁就绪时，中优先级任务可能被长期压制（护航效应）。本项目通过时间片轮转（Round Robin）作为保底机制来缓解：即使同优先级，也强制切换，避免单任务独占。具体实现为：当best_priority == current_priority且current_task->time_slice > 0时，不切换；仅当time_slice == 0或best_priority < current_priority时才切换。
// enhanced_scheduler.c —— 改进版调度逻辑 void scheduler() { int best_idx = -1; uint32_t best_prio = 0xFFFFFFFF; uint32_t current_prio = tasks[current_task_index].priority; for (int i = 0; i < task_count; i++) { if (tasks[i].state != TASK_RUNNING) continue; if (tasks[i].priority < best_prio) { best_prio = tasks[i].priority; best_idx = i; } } if (best_idx == -1) return; // no ready task // 抢占条件：更高优，或同优但当前时间片用完 if (best_prio < current_prio || (best_prio == current_prio && tasks[current_task_index].time_slice == 0)) { // save current tasks[current_task_index].ebp = read_ebp(); tasks[current_task_index].esp = read_esp(); // ... save other regs // load best current_task_index = best_idx; load_task_context(&tasks[best_idx]); } else { // 同优且时间片未尽：递减时间片，不切换 tasks[current_task_index].time_slice--; } }逻辑说明：
read_ebp()/read_esp()是内联汇编函数，直接读取寄存器。load_task_context()执行mov esp, [task->esp]等操作。关键设计：time_slice--放在 else 分支，确保同优先级任务能公平轮转。若放在 if 分支内，则只有切换时才减，导致不切换的任务时间片永不减少，违背轮转原则。
5. 常见问题排查：那些让你重启十次的“幽灵 Bug”
写裸机多任务，90% 的时间花在排查看似 trivial 的错误上。以下是我（某开发者）在模拟项目 X 中踩过的 5 个典型坑，按现象、原因、解决三步呈现，全是血泪经验。
5.1 现象：系统启动后黑屏，QEMU 提示 “Triple fault”，或物理机直接重启
原因：GDT 或 IDT 加载失败，或jmp 0x08:flush_cs后第一条指令非法。最常见的原因是gdt_descriptor中的base地址计算错误（如忘了& 0xFFFF取低 16 位），导致lgdt加载了错误的 GDT 地址，CPU 在保护模式下找不到有效的代码段描述符，触发 triple fault。
解决：用 QEMU 的-d int参数启动，查看详细中断日志；或在lgdt前加hlt指令，用 GDB 连接 QEMU（qemu-system-i386 -s -S），单步确认gdt_descriptor内存内容是否正确。重点检查dd gdt_start是否等于 GDT 在内存中的真实物理地址（可用objdump -d kernel.o查看符号地址，再加加载偏移）。
5.2 现象：第一个任务能运行，但切换到第二个任务后，屏幕乱码或死锁
原因：页表映射不完整。例如，任务 B 的页表中，内核代码段（0xC0000000 以上）未映射，导致iret后跳转到内核 ISR 时，CPU 尝试访问未映射的虚拟地址，触发 page fault。而 page fault 的 ISR 若未在 IDT 中正确定义（或其 ISR 本身又缺页），则陷入无限 fault 循环。
解决：在init_page_directory()中，确保所有任务的页目录高 256 项（0xC00~0x3FF）都映射到相同的物理页（内核代码/数据页）。用 QEMU 的-d mem查看内存访问，确认0xC0100000等地址是否被正确翻译。可在 page fault ISR 中打印cr2（故障地址）和error code，快速定位缺页位置。
5.3 现象：任务 A 和 B 都在运行，但 A 总是抢占 B，B 几乎得不到 CPU
原因：优先数比较逻辑错误。C 语言中priority若定义为int8_t，而tasks[i].priority被当作有符号数比较（如0xFF被解释为 -1），导致低地址任务被误判为“最高优”。或者，在汇编调度器中，cmp eax, ecx后用了jae（无符号比较），但priority是有符号数，-1（0xFFFFFFFF）会大于0，造成误判。
解决：统一使用uint32_t存储priority，并在所有比较处用无符号指令（cmp/jb）。在task_create()中添加断言：assert(priority < MAX_TASKS)，防止越界。打印每个任务的priority和state，确认数值符合预期。
5.4 现象：时钟中断 ISR 执行后，系统卡死，不再响应任何按键
原因：iret前未正确恢复所有寄存器，或pusha/popa与实际栈帧不匹配。例如，在 ISR 中push ds后，忘记pop ds；或popa时栈顶不是pusha的原始顺序，导致esp错乱。更隐蔽的是：若任务 C 的栈已满，pusha会覆盖相邻内存，破坏 GDT 或 IDT。
解决：严格遵循pusha→ 保存段寄存器 → 调度逻辑 → 恢复段寄存器 →popa→iret的顺序。用objdump检查 ISR 汇编，确认push/pop成对。为每个任务分配足够栈（TASK_STACK_SIZE >= 0x2000），并在task_create()中用memset(t->stack, 0xCC, sizeof(t->stack))填充，便于调试时识别栈溢出（0xCC 是int3指令，溢出后执行会触发断点）。
5.5 现象：任务能切换，但printf输出乱码，或字符串显示不全
原因：printf依赖 libc 的_write系统调用，而裸机无系统调用。若链接了部分 libc，其内部可能使用了未初始化的全局变量（如stdout文件结构体），或调用了malloc（而我们的内存管理器未提供malloc接口）。
解决：**彻底
本文还有配套的精品资源，点击获取
