《操作系统真象还原》第九章（2）——线程

《操作系统真象还原》第九章（2）——线程

前言

本篇博客是第九章线程的第二部分，第一部分我们实现了线程，实现了我们自己系统的链表，本章就是要实现多线程轮询机制。

第一部分链接：《操作系统真象还原》第九章（1）——线程-CSDN博客

---

多线程调度

简单优先级调度的基础

本节任务是把thread.c 和 thread.h 进一步完善，在原有线程的基础上添加新的功能。

thread.h新增部分

#include "../lib/kernel/list.h"
...
/* 线程或进程的pcb程序控制块 */
struct task_struct {uint32_t *self_kstack; // 线程自己的内核栈栈顶指针enum thread_status status; // 线程的状态uint8_t priority; // 线程的优先级uint8_t ticks; // 线程的时间片，在处理器上运行的时间滴答数uint32_t elapsed_ticks; // 线程的运行时间，也就是这个线程已经执行了多久struct list_elem general_tag; // 用于线程在一般队列中的节点struct list_elem all_list_tag; // 用于线程在thread_all_list队列中的节点uint32_t *pgdir; // 如果是进程，这是进程的页表的虚拟地址，线程则置为NULLchar name[16]; // 线程的名字uint32_t stack_magic; // 线程栈的魔数，边界标记，用来检测栈溢出};
...

thread.c更新后

#include "thread.h"
#include "../lib/kernel/stdint.h"
#include "../lib/string.h"
#include "global.h"
#include "../kernel/memory.h"
#include "interrupt.h"#define PAGE_SIZE 4096struct task_struct *main_thread; // 主线程pcb
struct list thread_ready_list; // 就绪线程队列
struct list thread_all_list; // 所有线程队列
static struct list_elem *thread_tag; // 用于保存队列中的线程节点extern void switch_to(struct task_struct *cur, struct task_struct *next); // 任务切换函数/* 获取当前线程的pcb指针 */
struct task_struct *running_thread(void) {uint32_t esp;asm volatile("movl %%esp, %0" : "=g"(esp)); // 获取当前线程的栈顶地址/* 取得esp整数部分 */return (struct task_struct *)(esp & 0xfffff000); // 返回pcb指针
}/* 由kernel_thread执行function(func_arg) */
static void kernel_thread(thread_func *function, void *func_arg) {intr_enable(); // 开中断,避免后面的时钟中断被屏蔽，而无法调度其他线程function(func_arg);//...
}/* 初始化线程栈thread_stack */
void thread_create(struct task_struct *pthread, thread_func function, void *func_arg) {/* 先预留中断栈空间 */pthread->self_kstack -= sizeof(struct intr_stack);/* 再预留线程栈空间 */pthread->self_kstack -= sizeof(struct thread_stack);/* 填充线程栈 */struct thread_stack *kthread_stack = (struct thread_stack *)pthread->self_kstack;kthread_stack->eip = kernel_thread; // eip指向kernel_threadkthread_stack->function = function; // 函数指针kthread_stack->func_arg = func_arg; // 函数参数kthread_stack->ebp = 0; // ebp寄存器值kthread_stack->ebx = 0; // ebx寄存器值kthread_stack->edi = 0; // edi寄存器值kthread_stack->esi = 0; // esi寄存器值
}/* 初始化线程基本信息 */
void init_thread(struct task_struct *pthread, char *name, int prio) {memset(pthread, 0, sizeof(*pthread)); // 清空线程pcbstrcpy(pthread->name, name); // 线程名字if(pthread == main_thread) { // 线程状态pthread->status = TASK_RUNNING;} else {pthread->status = TASK_READY;}/* self_kstack 是线程自己在内核态下使用的栈顶地址 */pthread->self_kstack = (uint32_t *)((uint32_t)pthread + PAGE_SIZE); // 线程内核栈pthread->priority = prio; // 线程优先级pthread->ticks = prio; // 线程时间片pthread->elapsed_ticks = 0; // 线程运行时间pthread->pgdir = NULL; // 线程页表pthread->stack_magic = 0x19870916; // 线程栈的魔数，边界标记，用来检测栈溢出
}/* 创建一个优先级为prio的线程，线程名是name，执行的函数是function(func_arg) */
struct task_struct *thread_start(char *name, int prio, thread_func function, void *func_arg) {struct task_struct *thread = get_kernel_pages(1); // 分配1页的内存空间给pcbinit_thread(thread, name, prio); // 初始化线程基本信息thread_create(thread, function, func_arg); // 初始化线程栈/* 确保线程不在就绪队列 */ASSERT(!elem_find(&thread_ready_list, &thread->general_tag));list_append(&thread_ready_list, &thread->general_tag); // 将线程加入就绪队列/* 确保线程不在所有线程队列 */ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag));list_append(&thread_all_list, &thread->all_list_tag); // 将线程加入所有线程队列return thread;
}/* 将kernel中的main函数完善成主线程 */
static void make_main_thread(void) {/* 因为main线程早已运行， *咱们在loader.S中进入内核时的mov esp,0xc009f000， * 就是为其预留pcb的，因此pcb地址为0xc009e000， * 不需要通过get_kernel_page另分配一页*/main_thread = running_thread(); // 获取主线程pcbinit_thread(main_thread, "main", 31); // 初始化主线程基本信息ASSERT(!elem_find(&thread_ready_list, &main_thread->all_list_tag)); // 确保主线程不在就绪队列list_append(&thread_ready_list, &main_thread->general_tag); // 将主线程加入就绪队列
}

任务调度器和任务切换

本节要实现调度器和任务切换，调度器的工作就是根据任务的状态将其从处理器上换上换下。

我们先梳理思路：调度器读写就绪队列，增删里面的节点，节点是general_tag，代表一个个pcb。

每发生一次时钟中断，时钟中断的处理程序便将当前运行 线程的ticks 减 1。当ticks 为 0 时，时钟的中断处理程序调用调度器schedule，也就是该把当前线程换下 处理器了，让调度器选择另一个线程上处理器。

调度器从就绪队列取出队首元素，将pcb里线程的状态置为running。然后通过switc_to函数将新线程的寄存器环境恢复，开始执行新线程。

其他函数也可以调用schedule，例如后续的thread_block函数，到时候再说。

总结一下，完整的调度过程需要三部分的配合。

1. 时钟中断处理函数。
2. 调度器schedule。
3. 任务切换函数switch_to。

注册时钟中断处理函数

我们之前的时钟中断函数使用的是通用函数general_intr_handler，也就是默认的中断处理函数。我们有两个打算：1.简单修改默认中断处理函数。2.写专门的时钟中断处理函数。

修改interrupt.c的general_intr_handler

/* 通用的中断处理函数,一般用在异常出现时的处理 */
static void general_intr_handler(uint8_t vec_nr) {if (vec_nr == 0x27 || vec_nr == 0x2f) {	// 0x2f是从片8259A上的最后一个irq引脚，保留return;		//IRQ7和IRQ15会产生伪中断(spurious interrupt),无须处理。}/* 将光标置为0，从屏幕左上角清出一片打印异常信息的区域，方便阅读 */ set_cursor(0);	// 设置光标位置为0int cursor_pos = 0;	// 光标位置while (cursor_pos < 320) {	// 清除屏幕put_char(' ');	// 打印空格cursor_pos++;	// 光标位置加1}set_cursor(0);	// 设置光标位置为0put_str("!!! exception message begin !!!\n");	// 打印异常信息set_cursor(88);put_str(intr_name[vec_nr]);	// 打印异常名称if (vec_nr == 14) {	// 如果是页面错误异常int page_fault_vaddr = 0;	// 页面错误地址/* cr2寄存器存放造成page_fault的地址 */asm volatile ("movl %%cr2, %0" : "=r" (page_fault_vaddr));	// 获取页面错误地址put_str("\npage fault addr is ");	// 打印页面错误地址put_int(page_fault_vaddr);	// 打印页面错误地址}put_str("  \n!!! exception message end !!!\n");	// 打印异常信息结束// 目前处在关中断状态，不再调度进程，下面的死循环不再被中断覆盖while (1);    // 进入死循环
}

特别说明一下新增的函数set_cursor，这个函数声明在print.h，实现是print.S中.set_cursor，我们先修改print.S

global set_cursor
.set set_cursor,.set_cursor

然后修改print.h

//这个头文件定义了打印函数的原型
//包括打印单个字符、打印字符串和打印16进制整数的函数
#ifndef __LIB_KERNEL_PRINT_H
#define __LIB_KERNEL_PRINT_H
#include "stdint.h"
extern void put_char (uint8_t char_asci);
extern void put_str  (char* message);
extern void put_int  (uint32_t number);
extern void set_cursor (uint32_t position);
#endif

修改time.c，完成时钟中断处理函数

//时钟中断相关
#include "timer.h"
#include "io.h"
#include "print.h"
#include "../kernel/interrupt.h"
#include "thread.h"
#include "debug.h"#define IRQ0_FREQUENCY 	100
#define INPUT_FREQUENCY        1193180
#define COUNTER0_VALUE		INPUT_FREQUENCY / IRQ0_FREQUENCY
#define COUNTER0_PORT		0X40
#define COUNTER0_NO 		0
#define COUNTER_MODE		2
#define READ_WRITE_LATCH	3
#define PIT_COUNTROL_PORT	0x43uint32_t ticks;	// ticks是时钟中断的次数void frequency_set(uint8_t counter_port ,uint8_t counter_no,uint8_t rwl,uint8_t counter_mode,uint16_t counter_value) {outb(PIT_COUNTROL_PORT,(uint8_t) (counter_no << 6 | rwl << 4 | counter_mode << 1));outb(counter_port,(uint8_t)counter_value);outb(counter_port,(uint8_t)counter_value >> 8);return;
} /* 时钟的中断处理函数 */
static void intr_timer_handler(void) {struct task_struct* cur_thread = running_thread();ASSERT(cur_thread->stack_magic == 0x19870916); // 检测栈溢出cur_thread->elapsed_ticks++; // 线程运行的时间加1// 每次时钟中断，ticks加1ticks++;if (cur_thread->ticks == 0) { // 如果当前线程的时间片用完schedule(); // 调度其他线程} else {cur_thread->ticks--; // 否则，当前线程的时间片减1}
}/* 初始化PIT8253 */ 
void timer_init(void) {put_str("timer_init start!\n");frequency_set(COUNTER0_PORT, \COUNTER0_NO, \READ_WRITE_LATCH, \COUNTER_MODE, \COUNTER0_VALUE);register_handler(0x20, intr_timer_handler); // 注册时钟中断处理函数put_str("timer_init done!\n");return;
}

关于新函数register_handler，它的实现在interrupt.c里，在exception_init函数之后，在idt_init函数之前

/* 在中断处理程序数组第vector_no个元素中 注册安装中断处理程序function */ 
void register_handler(uint8_t vector_no, intr_handler function) {idt_table[vector_no] = function;	// 注册中断处理函数
}

实现调度器schedule

依然是修改thread.c，给出新增部分

/* 实现任务调度 */
void scheduler(void) {ASSERT(intr_get_status() == INTR_OFF); // 确保中断关闭struct task_struct *cur = running_thread(); // 获取当前线程pcbif(cur->status == TASK_RUNNING) { // 如果当前线程是运行状态ASSERT(!elem_find(&thread_ready_list, &cur->general_tag)); // 确保当前线程不在就绪队列list_append(&thread_ready_list, &cur->general_tag); // 将当前线程加入就绪队列cur->ticks = cur->priority; // 重置时间片cur->status = TASK_READY; // 设置当前线程状态为就绪}else {/* 如果当前线程不是运行状态，则不需要重置时间片 */}ASSERT(!list_empty(&thread_ready_list)); // 确保就绪队列不为空thread_tag = NULL; // 清空线程节点thread_tag = list_pop(&thread_ready_list); // 从就绪队列中取出一个线程节点struct task_struct *next = elem2entry(struct task_struct, \general_tag, \thread_tag); // 获取下一个线程pcbnext->status = TASK_RUNNING; // 设置下一个线程状态为运行switch_to(cur, next); // 任务切换
}

关于宏elem2entry：这个宏定义在list.h

#define offset(struct_type,member) (int)(&((struct_type*)0)->member) 
#define elem2entry(struct_type, struct_member_name, elem_ptr) \ 
(struct_type*)((int)elem_ptr - offset(struct_type, struct_member_name))

这个elem2entry宏的作用获取某个结构体成员对应的结构体的地址，原理是是用 elem_ptr 的地址减去elem_ptr 在结构体struct_type 中的偏移量。偏移量通过宏offset获取。

实现任务切换函数switch_to

书上先提了一下上下文保护，放一张图片

说一下我的理解：开机->bios->mbr->loader->kernel_main，主线程完成中断初始化、计时器初始化、内存池初始化、多次线程初始化等。目前这一系列过程完成后，main线程被多线程系统管理。

中断初始化后，我们的计时器硬件每过一段时间就给cpu发一个中断信号，也就是进行所谓的时钟中断，执行任意中断处理程序时，先保存进入中断前的上下文环境，这部分是kernel.S完成的，称为上下文保护的第一部分。第一部分保护的寄存器环境放在中断栈里。

中断处理程序有始有终，其中调用了schedule，为了后续能结束，要保存中断处理程序运行过程中的上下文环境，称为上下文保护的第二部分。第二部分保护的寄存器环境放在线程栈里。

通过时钟中断的处理程序，运行schedule，schedule运行switch_to，switch_to中实现上下文保护的第二部分。

;switch_to函数接受两个参数，第1个参数是当前线程cur
;第2个参数是下一个上处理器的线程next
;此函数的功能是保存cur线程的寄存器映像，将下一个线程next的寄存器映像装载到处理器。
[bits 32]
section .text
global switch_to
switch_to:;-----以下是备份当前线程的上下文环境-----;第一个位置是返回地址push ESIpush EDIpush EBXpush EBPmov EAX,[esp+20]    mov [EAX],esp   ;获取cur，把esp保存到cur的结构体的self_kstack里;-----以下是恢复下一个线程的环境-----mov EAX,[esp+24]    mov esp,[EAX]   ;获取next，把esp指向next的结构体的self_kstackpop EBPpop EBXpop EDIpop ESIret             ;返回到scheduler

启用线程调度

thread.h完整代码

#ifndef __THREAD_THREAD_H
#define __THREAD_THREAD_H
#include "../lib/kernel/stdint.h"
#include "../lib/kernel/list.h"/* 自定义通用函数类型，用来承载线程中函数的类型 */
typedef void thread_func(void*);/* 进程、线程的状态 */
enum thread_status {TASK_RUNNING,  // 运行中TASK_READY,    // 就绪TASK_BLOCKED,  // 阻塞TASK_WAITING,  // 等待TASK_HANGING,  // 挂起TASK_DIED     // 死亡
};/***********   中断栈intr_stack   *********** 
* 此结构用于中断发生时保护程序（线程或进程）的上下文环境: 
* 进程或线程被外部中断或软中断打断时，会按照此结构压入上下文 
* 寄存器，intr_exit中的出栈操作是此结构的逆操作 
* 此栈在线程自己的内核栈中位置固定，所在页的最顶端 
********************************************/ 
/*进入中断后，在kernel.S中的中断入口程序“intr%1entry”所执行的上下
文保护的一系列压栈操作都是压入了此结构中。*/
struct intr_stack {uint32_t vec_no;   // 中断号uint32_t edi;      // 被中断的线程的edi寄存器值uint32_t esi;      // 被中断的线程的esi寄存器值uint32_t ebp;      // 被中断的线程的ebp寄存器值uint32_t esp_dummy; // 被中断的线程的esp寄存器值// 虽然pushad把esp也压入，但esp是不断变化的，所以会被popad忽略uint32_t ebx;      // 被中断的线程的ebx寄存器值uint32_t edx;      // 被中断的线程的edx寄存器值uint32_t ecx;      // 被中断的线程的ecx寄存器值uint32_t eax;      // 被中断的线程的eax寄存器值uint32_t gs;       // 被中断的线程的gs寄存器值uint32_t fs;       // 被中断的线程的fs寄存器值uint32_t es;       // 被中断的线程的es寄存器值uint32_t ds;       // 被中断的线程的ds寄存器值/* 以下由cpu从低特权级到高特权级时压入 */uint32_t err_code; // 错误码void (*eip)(void);      // 被中断的线程的eip寄存器值// eip是指向无参数无返回值的函数的指针uint32_t cs;       // 被中断的线程的cs寄存器值uint32_t eflags;   // 被中断的线程的eflags寄存器值void * esp;      // 被中断的线程的esp寄存器值uint32_t ss;       // 被中断的线程的ss寄存器值
};/***********  线程栈thread_stack  *********** 
* 线程自己的栈，用于存储线程中待执行的函数 
* 此结构在线程自己的内核栈中位置不固定， 
* 仅用在switch_to(任务切换)时保存线程环境。 
* 实际位置取决于实际运行情况。 
******************************************/
struct thread_stack {/*：关于下面四个寄存器，在被调函数运行完之后，这4个寄存器的值必须和运行前一样，它必须在自己的栈中存储这些寄存器的值。*/uint32_t ebp;   // 线程的ebp寄存器值uint32_t ebx;   // 线程的ebx寄存器值uint32_t edi;   // 线程的edi寄存器值uint32_t esi;   // 线程的esi寄存器值/* 线程第一次执行时，eip指向待调用的函数。其他时候，eip指向switch_to后新任务的返回地址 */void (*eip)(thread_func *func,void *func_arg);/* 以下函数，仅供线程第一次被调度到cpu时使用 */void (*unused_retaddr); // 未使用的返回地址，目前仅起到占位作用thread_func *function; // kernel_thread内核线程要执行的函数名void *func_arg;        // kernel_thread内核线程要执行的函数的参数
};/* 线程或进程的pcb程序控制块 */
struct task_struct {uint32_t *self_kstack; // 线程自己的内核栈栈顶指针enum thread_status status; // 线程的状态uint8_t priority; // 线程的优先级uint8_t ticks; // 线程的时间片，在处理器上运行的时间滴答数uint32_t elapsed_ticks; // 线程的运行时间，也就是这个线程已经执行了多久struct list_elem general_tag; // 用于线程在一般队列中的节点struct list_elem all_list_tag; // 用于线程在thread_all_list队列中的节点uint32_t *pgdir; // 如果是进程，这是进程的页表的虚拟地址，线程则置为NULLchar name[16]; // 线程的名字uint32_t stack_magic; // 线程栈的魔数，边界标记，用来检测栈溢出};struct task_struct *running_thread(void); // 获取当前线程的pcb指针
void thread_create(struct task_struct *pthread, thread_func function, void *func_arg); // 初始化线程栈
void init_thread(struct task_struct *pthread, char *name, int prio); // 初始化线程基本信息
struct task_struct *thread_start(char *name, int prio, thread_func function, void *func_arg); // 创建一个优先级为prio的线程，线程名是name，执行的函数是function(func_arg)
void schedule(void); // 线程调度函数
void thread_init(void); // 线程初始化函数
#endif

thread.c完整代码

#include "thread.h"
#include "../lib/string.h"
#include "../kernel/memory.h"
#include "interrupt.h"
#include "debug.h"
#include "print.h"#define PAGE_SIZE 4096struct task_struct *main_thread; // 主线程pcb
struct list thread_ready_list; // 就绪线程队列
struct list thread_all_list; // 所有线程队列
static struct list_elem *thread_tag; // 用于保存队列中的线程节点extern void switch_to(struct task_struct *cur, struct task_struct *next); // 任务切换函数/* 获取当前线程的pcb指针 */
struct task_struct *running_thread(void) {uint32_t esp;asm volatile("movl %%esp, %0" : "=g"(esp)); // 获取当前线程的栈顶地址/* 取得esp整数部分 */return (struct task_struct *)(esp & 0xfffff000); // 返回pcb指针
}/* 由kernel_thread执行function(func_arg) */
static void kernel_thread(thread_func *function, void *func_arg) {intr_enable(); // 开中断,避免后面的时钟中断被屏蔽，而无法调度其他线程function(func_arg);//...
}/* 初始化线程栈thread_stack */
void thread_create(struct task_struct *pthread, thread_func function, void *func_arg) {/* 先预留中断栈空间 */pthread->self_kstack -= sizeof(struct intr_stack);/* 再预留线程栈空间 */pthread->self_kstack -= sizeof(struct thread_stack);/* 填充线程栈 */struct thread_stack *kthread_stack = (struct thread_stack *)pthread->self_kstack;kthread_stack->eip = kernel_thread; // eip指向kernel_threadkthread_stack->function = function; // 函数指针kthread_stack->func_arg = func_arg; // 函数参数//kthread_stack->ebp = (uint32_t*)((uint32_t)pthread->self_kstack + sizeof(struct thread_stack)); // ebp指向线程栈kthread_stack->ebp = kthread_stack->ebx = \kthread_stack->esi = kthread_stack->edi = 0; // ebp, ebx, edi, esi寄存器值
}/* 初始化线程基本信息 */
void init_thread(struct task_struct *pthread, char *name, int prio) {memset(pthread, 0, sizeof(*pthread)); // 清空线程pcbstrcpy(pthread->name, name); // 线程名字if(pthread == main_thread) { // 线程状态pthread->status = TASK_RUNNING;} else {pthread->status = TASK_READY;}/* self_kstack 是线程自己在内核态下使用的栈顶地址 */pthread->self_kstack = (uint32_t *)((uint32_t)pthread + PAGE_SIZE); // 线程内核栈pthread->priority = prio; // 线程优先级pthread->ticks = prio; // 线程时间片pthread->elapsed_ticks = 0; // 线程运行时间pthread->pgdir = NULL; // 线程页表pthread->stack_magic = 0x19870916; // 线程栈的魔数，边界标记，用来检测栈溢出
}/* 创建一个优先级为prio的线程，线程名是name，执行的函数是function(func_arg) */
struct task_struct *thread_start(char *name, int prio, thread_func function, void *func_arg) {struct task_struct *thread = get_kernel_pages(1); // 分配1页的内存空间给pcbinit_thread(thread, name, prio); // 初始化线程基本信息thread_create(thread, function, func_arg); // 初始化线程栈/* 确保线程不在就绪队列 */ASSERT(!elem_find(&thread_ready_list, &thread->general_tag));list_append(&thread_ready_list, &thread->general_tag); // 将线程加入就绪队列/* 确保线程不在所有线程队列 */ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag));list_append(&thread_all_list, &thread->all_list_tag); // 将线程加入所有线程队列return thread;
}/* 将kernel中的main函数完善成主线程 */
static void make_main_thread(void) {/* 因为main线程早已运行， * 咱们在loader.S中进入内核时的mov esp,0xc009f000， * 就是为其预留pcb的，因此pcb地址为0xc009e000， * 不需要通过get_kernel_page另分配一页*/main_thread = running_thread(); // 获取主线程pcbinit_thread(main_thread, "main", 31); // 初始化主线程基本信息ASSERT(!elem_find(&thread_all_list, &main_thread->all_list_tag)); // 确保主线程不在就绪队列list_append(&thread_all_list, &main_thread->all_list_tag); // 将主线程加入就绪队列
}/* 实现任务调度 */
void schedule(void) {ASSERT(intr_get_status() == INTR_OFF); // 确保中断关闭struct task_struct *cur = running_thread(); // 获取当前线程pcbif(cur->status == TASK_RUNNING) { // 如果当前线程是运行状态ASSERT(!elem_find(&thread_ready_list, &cur->general_tag)); // 确保当前线程不在就绪队列list_append(&thread_ready_list, &cur->general_tag); // 将当前线程加入就绪队列cur->ticks = cur->priority; // 重置时间片cur->status = TASK_READY; // 设置当前线程状态为就绪}else {/* 如果当前线程不是运行状态，则不需要重置时间片 */}ASSERT(!list_empty(&thread_ready_list)); // 确保就绪队列不为空thread_tag = NULL; // 清空线程节点thread_tag = list_pop(&thread_ready_list); // 从就绪队列中取出一个线程节点struct task_struct *next = elem2entry(struct task_struct, \general_tag, \thread_tag); // 获取下一个线程pcbnext->status = TASK_RUNNING; // 设置下一个线程状态为运行switch_to(cur, next); // 任务切换
}/* 初始化线程环境 */
void thread_init(void) {put_str("thread_init start\n");list_init(&thread_ready_list); // 初始化就绪线程队列list_init(&thread_all_list); // 初始化所有线程队列make_main_thread(); // 创建主线程put_str("thread_init done\n");
}

得把thread_init加入到init.c 中

//完成所有的初始化工作
#include "init.h" 
#include "print.h" 
#include "interrupt.h" 
#include "timer.h"
#include "memory.h"
#include "thread.h"/*负责初始化所有模块 */ 
void init_all() {put_str("init_all\n"); // 打印初始化信息idt_init();            // 初始化中断timer_init();          // 初始化定时器mem_init();            // 初始化内存thread_init();         // 初始化线程
}

修改main.c

//内核的入口函数
#include "print.h"
#include "init.h"
#include "debug.h"
#include "memory.h"
#include "thread.h"
#include "interrupt.h"void k_thread_a(void *); //线程函数声明
void k_thread_b(void *); //线程函数声明
/* 主线程 */
int main(void){put_str("HongBai's OS\n");init_all();//初始化所有模块//中断测试，目前只完成了响应时钟中断//asm volatile("sti");//打开中断//asm volatile("cli");//关闭中断//断言测试//ASSERT(1 == 2); // 断言失败,会调用panic_spin函数//申请内存测试//void *addr = get_kernel_pages(3); //申请3页内存//put_str("get_kernel_pages start vaddr is: ");//put_int((uint32_t)addr); //输出虚拟地址//put_str("\n");//线程测试thread_start("k_thread_a", 31, k_thread_a, "threadA ");thread_start("k_thread_b", 8, k_thread_b, "threadB ");intr_enable(); //打开中断while(1) {//主线程循环put_str("main ");}return 0;
}/* 在线程中运行的函数 */
void k_thread_a(void *arg){char *para = arg;while(1){put_str(para);}
}/* 在线程中运行的函数 */
void k_thread_b(void *arg){char *para = arg;while(1){put_str(para);}
}

运行测试

可以看到三个线程同时交错运行。

结语

调试代码真的让人心力憔悴。6点钟初步完成这部分的代码，先是编译连接出若干报错，解决后运行出错，一直调试3个小时到现在。累得够呛，懒得再写测试过程了，前面的代码也不一定全部正确，仅供参考吧。