[自制操作系统] 第19回 实现用户进程(下)

目录
一、前景回顾
二、进程的创建与初始化
三、如何进行进程的切换
四、运行测试
五、原书勘误

 

一、前景回顾

　　在上一回我们大概讲述了任务切换的发展，并且知道Linux采用的是一个CPU使用一个TSS的方式，在最后我们成功实现了tss。现在万事俱备，我们正式来实现用户进程。

二、进程的创建与初始化

　　进程的创建与线程的创建很相似，这里直接上图来对比分析：

　　
　　我们使用process_execute函数来创建初始化进程。

/*创建用户进程*/  2 void process_execute(void *filename, char *name)  3 {  4     /*pcb内核的数据结构，由内核来维护进程信息，因此要在内核内存池中申请*/  5     struct task_struct *thread = get_kernel_pages(1);  6     init_thread(thread, name, 31);      7     thread_create(thread, start_process, filename);  8     create_user_vaddr_bitmap(thread);    //创建虚拟地址的位图  9     thread->pgdir = create_page_dir();   //用户进程的页目录表的物理地址，这里传进来的是页目录表物理地址所对应的虚拟地址 10  11     enum intr_status old_status = intr_disable(); 12     ASSERT(!elem_find(&thread_ready_list, &thread->general_tag)); 13     list_append(&thread_ready_list, &thread->general_tag); 14  15     ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag)); 16     list_append(&thread_all_list, &thread->all_list_tag); 17     intr_set_status(old_status); 18 }

　　在该函数中首先使用get_kernel_pages函数在内核物理空间中申请一页物理内存来作为进程的PCB，因为最终调度是由内核来操控的，所以PCB统一都在内核物理空间中申请。随后依旧调用init_thread()和thread_create()函数来初始化进程的PCB。

　　下面开始不一样了，create_user_vaddr_bitmap()函数的作用是给进程创建初始化位图。这里科普一下：我们都知道进程有4GB的虚拟空间，其中第1~3GB是分配给用户空间，第4GB是分配给内核空间，这是Linux下的分配习惯，我们照搬。而用户空间实际上只用上了0x08048000到0xc0000000这一部分。所以create_user_vaddr_bitmap()函数也就是将这一部分空间划分到用户的虚拟地址内存池中。

　　再来看create_page_dir()函数，我们知道操作系统被所有用户进程所共享，所以我们将用户进程页目录表中的第768~1023个页目录项用内核页目录表的第768~1023个页目录项代替，其实就是将内核所在的页目录项复制到进程页目录表中同等位置，这样就能让用户进程的高1GB空间指向内核。最后再将进程添加到全部队列和就绪队列中供调度。至此，用户进程就算创建初始化完毕了。

　　我们现在来看看进程的PCB的内容：

 　 

三、如何进行进程的切换

　　因为我们之前一直都是处于内核态下，也就是0特权级下。现在要切换到用户进程也就是用户态，3特权级下运行，和之前的切换不太一样。还是举例来说明吧。

　　假设当前内核线程A时间片用光了，在调度函数schedule()中会从就绪队列中弹出下一个进程B的PCB，根据PCB我们就知道了进程B的所有信息。不过接下来和之前线程的切换不一样了，首先调用process_activate()函数激活下一个内核线程或者进程的页表。对于内核线程来说，内核线程的页目录表在之前激活分页机制的时候就已经设定好了，被存放在0x10000地址处。如果不是内核线程，那么就需要将进程B的页目录表地址赋给CR3寄存器，因为CPU寻址是基于CR3寄存器中保存的页目录表的地址来寻址的。切换到进程B后，需要将进程B的页目录表地址赋给了CR3寄存器。

/*激活线程或进程的页表，更新tss中的esp0为进程的特权级0的栈*/  2 void process_activate(struct task_struct *p_thread)  3 {  4     ASSERT(p_thread != NULL);  5     //激活该线程或者进程的页表  6     page_dir_activate(p_thread);  7       8     if (p_thread->pgdir) {  //如果是进程那么需要在tss中填入0级特权栈的esp0  9         update_tss_esp(p_thread); 10     } 11 }

　　除此之外，还要将tss中的esp0字段更新为进程B的0级栈。前面已经说过，进程在由例如中断等操作从3特权级进入0特权级后，也就是进入内核态，使用的会是0特权级下的栈，不再是3特权级的栈。因此在这个地方我们需要给进程B更新0特权级栈。方便以后进程B进入内核态。这里我们可以看到，进程B的0特权级的栈顶指针指向进程B的PCB最高处。

/*更新tss中的esp0字段的值为pthread的0级栈*/ 2 void update_tss_esp(struct task_struct *pthread) 3 { 4     tss.esp0 = (uint32_t *)((uint32_t)pthread + PG_SIZE); 5 }

　　这一系列操作完成后，我们又回到switch_to函数，和前面讲线程切换也是一样，首先通过一系列的push操作，将当前内核线程A的寄存器信息压入栈中以便下次又被调度上CPU后可以恢复环境。随后从进程B的PCB中得到新的栈。此时进程B的栈的情况如下：
 　　　　　　　　

switch_to:  2     push esi            ;这里是根据ABI原则保护四个寄存器 放到栈里面  3     push edi  4     push ebx  5     push ebp  6       7     mov eax, [esp+20]    ;esp+20的位置是cur cur的pcb赋值给eax  8     mov [eax], esp       ;[eax]为pcb的内核栈指针变量 把当前环境的esp值记录下来  9      10     mov eax, [esp+24] 11     mov esp, [eax]        12  13     pop ebp 14     pop ebx 15     pop edi 16     pop esi 17     ret                 

　　进程B的还是通过一系列POP操作，最终调用*eip所指向的函数kernel_thread，在该函数中又调用*function所指向的函数start_process()，该函数代码如下：

void start_process(void *filename)  2 {  3     void *function = filename;  4     struct task_struct *cur = running_thread();  5     cur->self_kstack += sizeof(struct thread_stack);  6     struct intr_stack *proc_stack = (struct intr_stack *)cur->self_kstack;  7     proc_stack->edi = proc_stack->esi = proc_stack->ebp = proc_stack->esp_dummy = 0;  8     proc_stack->ebx = proc_stack->edx = proc_stack->ecx = proc_stack->eax = 0;  9     proc_stack->gs = 0; 10     proc_stack->ds = proc_stack->es = proc_stack->fs = SELECTOR_U_DATA;  //数据段选择子 11     proc_stack->eip = function; //函数地址 ip 12     proc_stack->cs = SELECTOR_U_CODE; //cs ip cs选择子 13     proc_stack->eflags = (EFLAGS_IOPL_0 | EFLAGS_MBS | EFLAGS_IF_1); //不能够关闭中断 ELFAG_IF_1 不然会导致无法调度 14     proc_stack->esp = (void *)((uint32_t)get_a_page(PF_USER, USER_STACK3_VADDR) + PG_SIZE); //栈空间在0xc0000000以下一页的地方 当然物理内存是操作系统来分配 15     proc_stack->ss = SELECTOR_U_DATA; //数据段选择子 16     asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory"); 17 }

　　来细品一下这个函数的内容。还记得前面的那个进程的PCB图吗？

 　　

　　首先通过running_thread函数获取到当前进程的PCB的地址。根据图中我们可以知道self_kstack一开始是被赋值指向栈顶，也就是线程栈的开始位置。经过cur->self_kstack += sizeof(struct thread_stack)后，现在self_kstack指向中断栈处了，如图所示。然后定义一个pro_stack指针指向self_kstack。这个先记住，待会儿会用上。

　　随后便是对一系列寄存器的初始化，重点关注ds、es、fs、cs、ss和gs这几个段寄存器的初始化，我们将它们初始化为用户进程下的3特权级的段选择子。因为在用户态下，我们是不能访问0特权级下的代码段和数据段的。对于gs寄存器，这里其实不管是否设置为0都无所谓，因为用户态下的程序是不能直接访问显存的，进程在从内核态进入用户态时会进行特权检查，如果gs段寄存器中的段选择子的特权等级高于进程返回后的特权等级，CPU就会自动将段寄存器gs给置0，如果用户进程一旦访问显存，就会报错。

　　再往下就给esp赋值，这个地方是为了当回到用户态空间后，给用户程序指定一个栈顶指针。这里我们将用户态的栈顶指针设置为用户态空间下的0xc0000000处。

　　最后通过内联汇编：

　　asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory");

　　将proc_stack所指向的值赋给当前进程的esp，也就是栈顶指针，前面我们知道proc_stack已经被赋好了值，为self_kstack。最后便是跳转到intr_exit处执行代码。

　　此时栈的情况如下：　　
                              　　
　　然后intr_exit的代码如下所示：

intr_exit: 2     add esp, 4 3     popad 4     pop gs 5     pop fs 6     pop es 7     pop ds 8     add esp, 4 9     iretd

　　看着代码就很好理解了，首先add esp, 4跳过栈中的vec_no，随后popad和pop操作弹出8个32位的通用寄存器和4个段寄存器。又是通过add esp, 4跳过栈中的err_code，最后执行iretd指令，将(*eip)、cs、eflags弹出，而我们事先已经将用户进程要运行的函数地址存放在eip中。最后，由于我们跳转后的用户态，它的特权级不同于当前内核态的特权级，所以需要恢复旧栈，CPU自动将栈中的esp和ss弹出。这些值在我们前面的start_process()函数中已经初始化完毕。至此我们就已经完成了内核态到用户态的转换。

四、运行测试

　　这里我贴上本章所有相关代码：

#include "process.h"   2 #include "thread.h"   3 #include "global.h"   4 #include "memory.h"   5 #include "debug.h"   6 #include "console.h"   7 #include "interrupt.h"   8 #include "tss.h"   9   10 extern void intr_exit(void);  11 extern struct list thread_ready_list;           //就绪队列  12 extern struct list thread_all_list;    13   14 void start_process(void *filename)  15 {  16     void *function = filename;  17     struct task_struct *cur = running_thread();  18     cur->self_kstack += sizeof(struct thread_stack);  19     struct intr_stack *proc_stack = (struct intr_stack *)cur->self_kstack;  20     proc_stack->edi = proc_stack->esi = proc_stack->ebp = proc_stack->esp_dummy = 0;  21     proc_stack->ebx = proc_stack->edx = proc_stack->ecx = proc_stack->eax = 0;  22     proc_stack->gs = 0;  23     proc_stack->ds = proc_stack->es = proc_stack->fs = SELECTOR_U_DATA;            //数据段选择子  24     proc_stack->eip = function;                                //函数地址 ip  25     proc_stack->cs = SELECTOR_U_CODE;                                //cs ip cs选择子  26     proc_stack->eflags = (EFLAGS_IOPL_0 | EFLAGS_MBS | EFLAGS_IF_1);                //不能够关闭中断 ELFAG_IF_1 不然会导致无法调度  27     proc_stack->esp = (void *)((uint32_t)get_a_page(PF_USER, USER_STACK3_VADDR) + PG_SIZE);    //栈空间在0xc0000000以下一页的地方 当然物理内存是操作系统来分配  28     proc_stack->ss = SELECTOR_U_DATA;                                //数据段选择子  29     asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory");  30 }  31   32   33 /*激活页表*/  34 void page_dir_activate(struct task_struct *p_thread)  35 {  36     //内核线程的页目录表的物理地址为0x100000  37     uint32_t pagedir_phy_addr = 0x100000;  38     if (p_thread->pgdir != NULL) { //说明下一个调用的是进程，否则是内核线程  39         pagedir_phy_addr = addr_v2p((uint32_t)p_thread->pgdir);  40     }  41   42     /*更新页目录寄存器CR3，使新页表生效*/  43     asm volatile("movl %0, %%cr3" : : "r" (pagedir_phy_addr) : "memory");  44 }  45   46 /*激活线程或进程的页表，更新tss中的esp0为进程的特权级0的栈*/  47 void process_activate(struct task_struct *p_thread)  48 {  49     ASSERT(p_thread != NULL);  50     //激活该线程或者进程的页表  51     page_dir_activate(p_thread);  52       53     if (p_thread->pgdir) {  //如果是进程那么需要在tss中填入0级特权栈的esp0  54         update_tss_esp(p_thread);  55     }  56 }  57   58 uint32_t *create_page_dir(void)  59 {  60     //用户进程的页表不能让用户直接访问到，所以在内核空间申请  61     uint32_t *page_dir_vaddr = get_kernel_pages(1);                //得到内存  62     if (page_dir_vaddr == NULL) {  63         console_put_str("create_page_dir: get_kernel_page failed!n");  64         return NULL;  65     }  66       67     memcpy((uint32_t*)((uint32_t)page_dir_vaddr + 0x300 * 4), (uint32_t*)(0xfffff000 + 0x300 * 4), 1024); // 256项  68     uint32_t new_page_dir_phy_addr = addr_v2p((uint32_t)page_dir_vaddr);                      69     page_dir_vaddr[1023] = new_page_dir_phy_addr | PG_US_U | PG_RW_W | PG_P_1;                    //最后一项是页目录项自己的地址  70       71     return page_dir_vaddr;                                           72 }  73   74   75 /*创建用户进程虚拟地址位图*/  76 void create_user_vaddr_bitmap(struct task_struct *user_prog)  77 {  78     user_prog->userprog_vaddr.vaddr_start = USER_VADDR_START;  79       80     //计算需要多少物理内存页来记录位图 USER_VADDR_START为0x08048000  81     uint32_t bitmap_pg_cnt = DIV_ROUND_UP((0xc0000000 - USER_VADDR_START) / PG_SIZE / 8, PG_SIZE);   82     user_prog->userprog_vaddr.vaddr_bitmap.bits = get_kernel_pages(bitmap_pg_cnt);  83   84     user_prog->userprog_vaddr.vaddr_bitmap.btmp_bytes_len = (0xc0000000 - USER_VADDR_START) / PG_SIZE / 8;  85     bitmap_init(&user_prog->userprog_vaddr.vaddr_bitmap);  86 }  87   88 /*创建用户进程*/  89 void process_execute(void *filename, char *name)  90 {  91     /*pcb内核的数据结构，由内核来维护进程信息，因此要在内核内存池中申请*/  92     struct task_struct *thread = get_kernel_pages(1);  93     init_thread(thread, name, 31);      94     thread_create(thread, start_process, filename);  95     create_user_vaddr_bitmap(thread);    //创建虚拟地址的位图  96     thread->pgdir = create_page_dir();   //用户进程的页目录表的物理地址，这里传进来的是页目录表物理地址所对应的虚拟地址  97   98     enum intr_status old_status = intr_disable();  99     ASSERT(!elem_find(&thread_ready_list, &thread->general_tag)); 100     list_append(&thread_ready_list, &thread->general_tag); 101  102     ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag)); 103     list_append(&thread_all_list, &thread->all_list_tag); 104     intr_set_status(old_status); 105 }

#ifndef  __USERPROG_PROCESS_H  2 #define  __USERPROG_PROCESS_H  3 #include "stdint.h"  4 #include "thread.h"  5   6 #define USER_STACK3_VADDR (0xc0000000 - 0x1000)  7 #define USER_VADDR_START 0x08048000  8   9  10 void process_execute(void *filename, char *name); 11 void create_user_vaddr_bitmap(struct task_struct *user_prog); 12 uint32_t *create_page_dir(void); 13 void process_activate(struct task_struct *p_thread); 14 void page_dir_activate(struct task_struct *p_thread); 15 void start_process(void *filename); 16  17 #endif

#include "memory.h"   2 #include "print.h"   3 #include "stdio.h"   4 #include "debug.h"   5 #include "string.h"   6 #include "thread.h"   7 #include "sync.h"   8    9 #define PG_SIZE 4096     //页大小  10   11 /*0xc0000000是内核从虚拟地址3G起，  12 * 0x100000意指低端内存1MB，为了使虚拟地址在逻辑上连续  13 * 后面申请的虚拟地址都从0xc0100000开始  14 */  15 #define K_HEAP_START 0xc0100000   16   17 #define PDE_IDX(addr) ((addr & 0xffc00000) >> 22)  18 #define PTE_IDX(addr) ((addr & 0x003ff000) >> 12)  19   20 struct pool {  21     struct bitmap pool_bitmap;     //本内存池用到的位图结构  22     uint32_t phy_addr_start;       //本内存池管理的物理内存的起始地址   23     uint32_t pool_size;            //内存池的容量  24     struct lock lock;  25 };  26   27 struct pool kernel_pool, user_pool;  //生成内核内存池和用户内存池  28 struct virtual_addr kernel_vaddr;    //此结构用来给内核分配虚拟地址  29   30   31 /*初始化内存池*/  32 static void mem_pool_init(uint32_t all_mem)   33 {  34     put_str("mem_pool_init startn");  35     /*目前页表和页目录表的占用内存  36     * 1页页目录表 + 第0和第768个页目录项指向同一个页表 + 第769～1022个页目录项共指向254个页表 = 256个页表  37     */  38     lock_init(&kernel_pool.lock);  39     lock_init(&user_pool.lock);  40   41     uint32_t page_table_size = PG_SIZE * 256;  42     uint32_t used_mem = page_table_size + 0x100000;  //目前总共用掉的内存空间  43     uint32_t free_mem = all_mem - used_mem;          //剩余内存为32MB-used_mem  44     uint16_t all_free_pages = free_mem / PG_SIZE;    //将剩余内存划分为页，余数舍去，方便计算  45       46     /*内核空间和用户空间各自分配一半的内存页*/  47     uint16_t kernel_free_pages = all_free_pages / 2;   48     uint16_t user_free_pages = all_free_pages - kernel_free_pages;   49   50     /*为简化位图操作，余数不用做处理，坏处是这样会丢内存，不过只要内存没用到极限就不会出现问题*/  51     uint32_t kbm_length = kernel_free_pages / 8; //位图的长度单位是字节  52     uint32_t ubm_length = user_free_pages / 8;  53   54     uint32_t kp_start = used_mem;                                 //内核内存池的起始物理地址  55     uint32_t up_start = kp_start + kernel_free_pages * PG_SIZE;   //用户内存池的起始物理地址  56   57     /*初始化内核用户池和用户内存池*/  58     kernel_pool.phy_addr_start = kp_start;  59     user_pool.phy_addr_start = up_start;  60   61     kernel_pool.pool_size = kernel_free_pages * PG_SIZE;   62     user_pool.pool_size = user_free_pages * PG_SIZE;  63   64     kernel_pool.pool_bitmap.btmp_bytes_len = kbm_length;  65     user_pool.pool_bitmap.btmp_bytes_len = ubm_length;  66   67     /***********内核内存池和用户内存池位图************  68     *内核的栈底是0xc009f00，减去4KB的PCB大小，便是0xc009e00  69     *这里再分配4KB的空间用来存储位图，那么位图的起始地址便是  70     *0xc009a00,4KB的空间可以管理4*1024*8*4KB=512MB的物理内存  71     *这对于我们的系统来说已经绰绰有余了。  72     */  73     /*内核内存池位图地址*/  74     kernel_pool.pool_bitmap.bits = (void *)MEM_BIT_BASE;  //MEM_BIT_BASE(0xc009a00)  75     /*用户内存池位图地址紧跟其后*/  76     user_pool.pool_bitmap.bits = (void *)(MEM_BIT_BASE + kbm_length);  77   78     /*输出内存池信息*/  79     put_str("kernel_pool_bitmap_start:");  80     put_int((int)kernel_pool.pool_bitmap.bits);  81     put_str("n");  82     put_str("kernel_pool.phy_addr_start:");  83     put_int(kernel_pool.phy_addr_start);  84     put_str("n");  85   86     put_str("user_pool_bitmap_start:");  87     put_int((int)user_pool.pool_bitmap.bits);  88     put_str("n");  89     put_str("user_pool.phy_addr_start:");  90     put_int(user_pool.phy_addr_start);  91     put_str("n");  92   93     /*将位图置0*/  94     bitmap_init(&kernel_pool.pool_bitmap);  95     bitmap_init(&user_pool.pool_bitmap);  96   97     /*初始化内核虚拟地址的位图，按照实际物理内存大小生成数组*/  98     kernel_vaddr.vaddr_bitmap.btmp_bytes_len = kbm_length;  99     /*内核虚拟地址内存池位图地址在用户内存池位图地址其后*/ 100     kernel_vaddr.vaddr_bitmap.bits = (void *)(MEM_BIT_BASE + kbm_length + ubm_length); 101     /*内核虚拟地址内存池的地址以K_HEAP_START为起始地址*/ 102     kernel_vaddr.vaddr_start = K_HEAP_START; 103     bitmap_init(&kernel_vaddr.vaddr_bitmap); 104  105     put_str("mem_pool_init donen"); 106 } 107  108 /*内存管理部分初始化入口*/ 109 void mem_init(void) 110 { 111     put_str("mem_init startn"); 112     uint32_t mem_bytes_total = 33554432; //32MB内存 32*1024*1024=33554432 113     mem_pool_init(mem_bytes_total); 114     put_str("mem_init donen"); 115 } 116  117  118 /*在pf表示的虚拟内存池中申请pg_cnt个虚拟页 119 * 成功则返回虚拟地址的起始地址，失败返回NULL 120 */ 121 static void *vaddr_get(enum pool_flags pf, uint32_t pg_cnt) 122 { 123     int vaddr_start = 0; 124     int bit_idx_start = -1; 125     uint32_t cnt = 0; 126     if (pf == PF_KERNEL) { 127         bit_idx_start = bitmap_scan(&kernel_vaddr.vaddr_bitmap, pg_cnt); 128         if (bit_idx_start == -1) { 129             return NULL; 130         } 131         /*在位图中将申请到的虚拟内存页所对应的位给置1*/ 132         while (cnt < pg_cnt) { 133             bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1); 134         } 135         vaddr_start = kernel_vaddr.vaddr_start + bit_idx_start * PG_SIZE; 136              137     } else {   //用户内存池 138         struct task_struct *cur = running_thread(); 139         bit_idx_start = bitmap_scan(&cur->userprog_vaddr.vaddr_bitmap, pg_cnt); 140         if (bit_idx_start == -1) { 141             return NULL; 142         } 143         while (cnt < pg_cnt) { 144             bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1); 145         } 146         vaddr_start = cur->userprog_vaddr.vaddr_start + bit_idx_start * PG_SIZE; 147         /*0xc00000000 - PG_SIZE作为用户3级栈已经在start_process被分配*/ 148         ASSERT((uint32_t)vaddr_start < (0xc0000000 - PG_SIZE)); 149     } 150     return (void *)vaddr_start; 151 } 152  153 /*得到虚拟地址vaddr所对应的pte指针 154 * 这个指针也是一个虚拟地址，CPU通过这个虚拟地址去寻址会得到一个真实的物理地址 155 * 这个物理地址便是存放虚拟地址vaddr对应的普通物理页的地址 156 * 假设我们已经知道虚拟地址vaddr对应的普通物理页地址为0xa 157 * 那么便可以通过如下操作完成虚拟地址和普通物理页地址的映射 158 * *pte = 0xa 159 */ 160 uint32_t *pte_ptr(uint32_t vaddr)  161 { 162     uint32_t *pte = (uint32_t *)(0xffc00000 +  163             ((vaddr & 0xffc00000) >> 10) +  164             PTE_IDX(vaddr) * 4); 165     return pte; 166 } 167  168 /*得到虚拟地址vaddr所对应的pde指针 169 * 这个指针也是一个虚拟地址，CPU通过这个虚拟地址去寻址会得到一个真实的物理地址 170 * 这个物理地址便是存放虚拟地址vaddr对应的页表的地址，使用方法同pte_ptr()一样 171 */ 172 uint32_t *pde_ptr(uint32_t vaddr)  173 { 174     uint32_t *pde = (uint32_t *)(0xfffff000 + PDE_IDX(vaddr) * 4); 175     return pde; 176 } 177  178 /*在m_pool指向的物理内存地址中分配一个物理页 179 * 成功则返回页框的物理地址，失败返回NULL 180 */ 181 static void *palloc(struct pool *m_pool) 182 { 183     int bit_idx = bitmap_scan(&m_pool->pool_bitmap, 1); 184     if (bit_idx == -1) { 185         return NULL; 186     } 187     /*在位图中将申请到的物理内存页所对应的位给置1*/ 188     bitmap_set(&m_pool->pool_bitmap, bit_idx, 1); 189     /*得到申请的物理页所在地址*/ 190     uint32_t page_phyaddr = (m_pool->phy_addr_start + bit_idx * PG_SIZE); 191     192     return (void *)page_phyaddr; 193 } 194  195 /*在页表中添加虚拟地址_vaddr与物理地址_page_phyaddr的映射*/ 196 static void page_table_add(void *_vaddr, void *_page_phyaddr) 197 { 198     uint32_t vaddr = (uint32_t)_vaddr; 199     uint32_t page_phyaddr = (uint32_t)_page_phyaddr; 200     uint32_t *pde = pde_ptr(vaddr); 201     uint32_t *pte = pte_ptr(vaddr); 202      203     //先判断虚拟地址对应的pde是否存在 204     if (*pde & 0x00000001) { 205         ASSERT(!(*pte & 0x00000001)); 206         *pte = (page_phyaddr | PG_US_U | PG_RW_W | PG_P_1); 207     } else { //页目录项不存在，需要先创建页目录再创建页表项 208         uint32_t pde_phyaddr = (uint32_t)palloc(&kernel_pool); 209         *pde = (pde_phyaddr | PG_US_U | PG_RW_W | PG_P_1); 210         /* 将分配到的物理页地址pde_phyaddr对应的物理内存清0 211         *  避免里面的陈旧数据变成页表项 212         */ 213         /* 这个地方不能这样memset((void *)pde_phyaddr, 0, PG_SIZE); 214         * 因为现在我们所使用的所有地址都是虚拟地址，虽然我们知道pde_phyaddr是真实的物理地址 215         * 可是CPU是不知道的，CPU会把pde_phyaddr当作虚拟地址来使用，这样就肯定无法清0了 216         * 所以解决问题的思路就是：如何得到pde_phyaddr所对应的虚拟地址。 217         */ 218         //为什么不是memset((void *)((int)pde & 0xffc00000), 0, PG_SIZE); 219         //建议好好看看pde_ptr()和pte_ptr()函数的实现 220         memset((void *)((int)pte & 0xfffff000), 0, PG_SIZE); 221         ASSERT(!(*pte & 0x00000001)); 222         *pte = (page_phyaddr | PG_US_U | PG_RW_W | PG_P_1); 223     } 224 } 225  226 /*分配pg_cnt个页空间，成功则返回起始虚拟地址，失败返回NULL*/ 227 void *malloc_page(enum pool_flags pf, uint32_t pg_cnt) 228 { 229     ASSERT((pg_cnt > 0) && (pg_cnt < 3840)); 230     void *vaddr_start = vaddr_get(pf, pg_cnt); 231     if (vaddr_start == NULL) { 232         return NULL; 233     } 234  235     uint32_t vaddr = (uint32_t)vaddr_start; 236     uint32_t cnt = pg_cnt; 237  238     struct pool *mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool; 239  240     /*因为虚拟地址连续，而物理地址不一定连续，所以逐个做映射*/ 241     while (cnt-- > 0) { 242         void *page_phyaddr = palloc(mem_pool); 243         if (page_phyaddr == NULL) { 244             return NULL; 245         } 246         page_table_add((void *)vaddr, page_phyaddr); 247         vaddr += PG_SIZE; 248     } 249     return vaddr_start; 250 } 251  252 /*从内核物理内存池中申请pg_cnt页内存，成功返回其虚拟地址，失败返回NULL*/ 253 void *get_kernel_pages(uint32_t pg_cnt) 254 { 255     void *vaddr = malloc_page(PF_KERNEL, pg_cnt); 256     if (vaddr != NULL) { 257         memset(vaddr, 0, pg_cnt * PG_SIZE); 258     } 259     return vaddr; 260 } 261  262  263 /*在用户空间中申请4K内存，并返回其虚拟地址*/ 264 void *get_user_pages(uint32_t pg_cnt) 265 { 266     lock_acquire(&user_pool.lock); 267     void *vaddr = malloc_page(PF_USER, pg_cnt); 268     memset(vaddr, 0, pg_cnt * PG_SIZE); 269     lock_release(&user_pool.lock); 270     return vaddr; 271 } 272  273 /*将地址vaddr与pf池中的物理地址关联起来，仅支持一页内存空间分配*/ 274 void *get_a_page(enum pool_flags pf, uint32_t vaddr) 275 { 276     struct pool *mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool; 277     lock_acquire(&mem_pool->lock); 278  279     struct task_struct* cur = running_thread(); 280     int32_t bit_idx = -1; 281      282     //虚拟地址位图置1 283     if (cur->pgdir != NULL && pf == PF_USER) { 284         bit_idx = (vaddr - cur->userprog_vaddr.vaddr_start) / PG_SIZE; 285         ASSERT(bit_idx > 0); 286         bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx, 1); 287     } else if(cur->pgdir == NULL && pf == PF_KERNEL) { 288         bit_idx = (vaddr - kernel_vaddr.vaddr_start) / PG_SIZE; 289         ASSERT(bit_idx > 0); 290         bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx, 1); 291     } else { 292         PANIC("get_a_page:not allow kernel alloc userspace or user alloc kernelspace by get_a_page"); 293     } 294      295     void* page_phyaddr = palloc(mem_pool); 296     if (page_phyaddr == NULL) 297         return NULL; 298     page_table_add((void *)vaddr, page_phyaddr); 299     lock_release(&mem_pool->lock); 300     return (void *)vaddr; 301 } 302  303 /*得到虚拟地址映射的物理地址*/ 304 uint32_t addr_v2p(uint32_t vaddr) 305 { 306     uint32_t *pte = pte_ptr(vaddr); 307     return ((*pte & 0xfffff000) + (vaddr & 0x00000fff)); 308 }

#ifndef  __KERNEL_MEMORY_H  2 #define  __KERNEL_MEMORY_H  3 #include "stdint.h"  4 #include "bitmap.h"  5   6 #define MEM_BIT_BASE 0xc009a000  7   8 /*虚拟地址池，用于虚拟地址管理*/  9 struct virtual_addr { 10     struct bitmap vaddr_bitmap;      //虚拟地址用到的位图结构 11     uint32_t vaddr_start;            //虚拟地址起始地址 12 }; 13  14 /*内存池标记，用于判断用哪个内存池*/ 15 enum pool_flags { 16     PF_KERNEL = 1, 17     PF_USER = 2 18 }; 19  20 #define  PG_P_1    1   //页表项或页目录项存在属性位，存在 21 #define  PG_P_0    0   //页表项或页目录项存在属性位，不存在 22 #define  PG_RW_R   0   //R/W属性位值，不可读/不可写 23 #define  PG_RW_W   2   //R/W属性位值，可读/可写 24 #define  PG_US_S   0   //U/S属性位值，系统级 25 #define  PG_US_U   4   //U/S属性位值，用户级 26  27 void mem_init(void); 28 void *get_kernel_pages(uint32_t pg_cnt); 29 void *get_a_page(enum pool_flags pf, uint32_t vaddr); 30 void *get_user_pages(uint32_t pg_cnt); 31 uint32_t addr_v2p(uint32_t vaddr); 32 void *get_a_page(enum pool_flags pf, uint32_t vaddr); 33  34 #endif

#include "thread.h"   2 #include "string.h"   3 #include "memory.h"   4 #include "list.h"   5 #include "interrupt.h"   6 #include "debug.h"   7 #include "print.h"   8 #include "stddef.h"   9 #include "process.h"  10   11 struct task_struct *main_thread;         //主线程PCB  12 struct list thread_ready_list;           //就绪队列  13 struct list thread_all_list;             //所有人物队列  14 static struct list_elem *thread_tag;     //用于保存队列中的线程节点  15 extern void switch_to(struct task_struct* cur, struct task_struct* next);  16   17   18 /*获取当前线程PCB指针*/  19 struct task_struct *running_thread(void)  20 {  21     uint32_t esp;  22     asm volatile ("mov %%esp, %0" : "=g" (esp));  23   24     /*取esp整数部分，即PCB起始地址*/  25     return (struct task_struct *)(esp & 0xfffff000);  26 }  27   28 /*由kernel_thread去执行function(func_arg)*/  29 static void kernel_thread(thread_func *function, void *func_arg)  30 {  31     /*执行function前要开中断，避免后面的时钟中断被屏蔽，而无法调度其他线程*/  32     intr_enable();  33     function(func_arg);  34 }  35   36 /*初始化线程PCB*/  37 void init_thread(struct task_struct *pthread, char *name, int prio)  38 {  39     memset(pthread, 0, sizeof(*pthread));  40     strcpy(pthread->name, name);  41   42     /*由于main函数也封装成了一个线程，并且他是一直在运行的，所以将其直接设置为TASK_RUNNING*/  43     if (pthread == main_thread) {  44         pthread->status = TASK_RUNNING;  45     } else {  46         pthread->status = TASK_READY;  47     }  48     //pthread->status = TASK_RUNNING;  49     pthread->priority = prio;  50     pthread->ticks = prio;  51     pthread->elapsed_ticks = 0;  52     pthread->pgdir = NULL;  53     pthread->self_kstack = (uint32_t *)((uint32_t)pthread + PG_SIZE);  54     pthread->stack_magic = 0x19870916;  55 }  56   57 void thread_create(struct task_struct *pthread, thread_func function, void *func_arg)  58 {  59     pthread->self_kstack -= sizeof(struct intr_stack);  60     pthread->self_kstack -= sizeof(struct thread_stack);  61   62     //初始化线程栈  63     struct thread_stack *kthread_stack = (struct thread_stack *)pthread->self_kstack;  64     kthread_stack->eip = kernel_thread;  65     kthread_stack->function = function;  66     kthread_stack->func_arg = func_arg;  67     kthread_stack->ebp = kthread_stack->ebx = kthread_stack->edi = kthread_stack->esi = 0;  68 }  69   70 /*创建一个优先级为prio的线程，线程名字为name，线程所执行的函数为function(func_arg)*/  71 struct task_struct *thread_start(char *name, int prio, thread_func function, void *func_arg)  72 {  73     /*创建线程的pcb，大小为4kb*/  74     struct task_struct *thread = get_kernel_pages(1);  75     init_thread(thread, name, prio);  76     thread_create(thread, function, func_arg);  77   78     /*确保之前不在队列中*/  79     ASSERT(!elem_find(&thread_ready_list, &thread->general_tag));  80   81     /*加入就绪线程队列*/  82     list_append(&thread_ready_list, &thread->general_tag);  83   84     /*确保之前不在队列*/  85     ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag));  86       87     /*加入全部线程队列*/  88     list_append(&thread_all_list, &thread->all_list_tag);  89   90     return thread;  91 }  92   93 static void make_main_thread(void)  94 {  95     main_thread = running_thread();  96     init_thread(main_thread, "main", 31);  97   98     /*main函数是当前线程，当前线程不在thread_ready_list,所以只能将其加在thread_all_list*/  99     ASSERT(!elem_find(&thread_all_list, &main_thread->all_list_tag)); 100     list_append(&thread_all_list, &main_thread->all_list_tag); 101 } 102  103 /*实现任务调度*/ 104 void schedule(void) 105 { 106     ASSERT(intr_get_status() == INTR_OFF); 107     struct task_struct *cur = running_thread(); 108     if (cur->status == TASK_RUNNING) { 109         ASSERT(!elem_find(&thread_ready_list, &cur->general_tag)); 110         list_append(&thread_ready_list, &cur->general_tag); 111         cur->ticks = cur->priority; 112         cur->status = TASK_READY; 113     } else { 114         /*阻塞等其他情况*/ 115     } 116  117     ASSERT(!list_empty(&thread_ready_list)); 118     thread_tag = NULL; 119     thread_tag = list_pop(&thread_ready_list); 120      121     struct task_struct *next = elem2entry(struct task_struct, general_tag, thread_tag); 122     next->status = TASK_RUNNING; 123  124     process_activate(next); 125     switch_to(cur, next); 126 } 127  128 /*初始化线程环境*/ 129 void thread_init(void) 130 { 131     put_str("thread_init startn"); 132     list_init(&thread_ready_list); 133     list_init(&thread_all_list); 134     /*将当前main函数创建为线程*/ 135     make_main_thread(); 136     put_str("thread_init donen"); 137 } 138  139 /*当前线程将自己阻塞，标志其状态为stat*/ 140 void thread_block(enum task_status stat) 141 { 142     /*stat取值为TASK_BLOCKED、TASK_WAITING、TASK_HANGING 143     这三种状态才不会被调度*/ 144     ASSERT(((stat == TASK_BLOCKED) || (stat == TASK_WAITING) || (stat == TASK_HANGING))); 145     enum intr_status old_status = intr_disable(); 146     struct task_struct *cur_thread = running_thread(); 147     cur_thread->status = stat; 148     schedule(); 149     intr_set_status(old_status); 150 } 151  152 /*将线程thread解除阻塞*/ 153 void thread_unblock(struct task_struct *thread) 154 { 155     enum intr_status old_status = intr_disable(); 156     ASSERT(((thread->status == TASK_BLOCKED) || (thread->status == TASK_WAITING) || (thread->status == TASK_HANGING))); 157     if (thread->status != TASK_READY) { 158         ASSERT(!elem_find(&thread_ready_list, &thread->general_tag)); 159         if (elem_find(&thread_ready_list, &thread->general_tag)) { 160             PANIC("thread_unblock: blocked thread in ready_list!n"); 161         } 162         list_push(&thread_ready_list, &thread->general_tag); 163         thread->status = TASK_READY; 164     } 165     intr_set_status(old_status); 166 }

#ifndef  __KERNEL_THREAD_H  2 #define  __KERNEL_THREAD_H  3 #include "stdint.h"  4 #include "list.h"  5 #include "memory.h"  6   7 /*自定义通用函数类型，它将在很多线程函数中作为形参类型*/  8 typedef void thread_func (void *);  9 #define PG_SIZE 4096 10 /*进程或线程的状态*/ 11 enum task_status { 12     TASK_RUNNING, 13     TASK_READY, 14     TASK_BLOCKED, 15     TASK_WAITING, 16     TASK_HANGING, 17     TASK_DIED 18 }; 19  20 /****************中断栈intr_stack****************/ 21 struct intr_stack { 22     uint32_t vec_no; 23     uint32_t edi; 24     uint32_t esi; 25     uint32_t ebp; 26     uint32_t esp_dummy; 27     uint32_t ebx; 28     uint32_t edx; 29     uint32_t ecx; 30     uint32_t eax; 31     uint32_t gs; 32     uint32_t fs; 33     uint32_t es; 34     uint32_t ds; 35  36 /*以下由cpu从低特权级进入高特权级时压入*/ 37     uint32_t err_code; 38     void (*eip)(void); 39     uint32_t cs; 40     uint32_t eflags; 41     void *esp; 42     uint32_t ss; 43 }; 44  45 /***************线程栈thread_stack**********/ 46 struct thread_stack  47 { 48     uint32_t ebp; 49     uint32_t ebx; 50     uint32_t edi; 51     uint32_t esi; 52  53     void (*eip) (thread_func *func, void *func_arg); 54     void (*unused_retaddr); 55     thread_func *function; 56     void *func_arg; 57 }; 58  59 /************进程或者线程的pcb,程序控制块**********/ 60 struct task_struct 61 { 62     uint32_t *self_kstack;    //每个内核线程自己的内核栈 63     enum task_status status; 64     uint8_t priority; 65      66     char name[16]; 67     uint8_t ticks;            //每次在处理器上执行的时间滴答数 68  69     /*此任务自从上CPU运行至今占用了多少滴答数，也就是这个任务执行了多久时间*/ 70     uint32_t elapsed_ticks; 71  72     /*general_tag的作用是用于线程在一般的队列中的节点*/ 73     struct list_elem general_tag; 74  75     /*all_list_tag的作用是用于线程thread_all_list的节点*/ 76     struct list_elem all_list_tag; 77  78     uint32_t *pgdir;//进程自己页表的虚拟地址 79  80     struct virtual_addr userprog_vaddr;   //用户进程的虚拟地址池 81  82     uint32_t stack_magic; 83 }; 84  85 void schedule(void); 86 struct task_struct *running_thread(void); 87 static void kernel_thread(thread_func *function, void *func_arg); 88 void init_thread(struct task_struct *pthread, char *name, int prio); 89 void thread_create(struct task_struct *pthread, thread_func function, void *func_arg); 90 struct task_struct *thread_start(char *name, int prio, thread_func function, void *func_arg); 91 static void make_main_thread(void); 92 void thread_init(void); 93 void thread_block(enum task_status stat); 94 void thread_unblock(struct task_struct *thread); 95  96  97 #endif

　　修改main.c文件，本来用户进程在执行前，是由操作系统的程序加载起将用户程序从文件系统直接读取到内存，再根据程序文件的格式解析其内容，将程序中的段展开到相应的内存地址。程序格式会记录程序的入口地址，CPU把CS:[E]IP指向它，该程序就被执行了，C语言虽然不能直接控制这两个寄存器，但是函数调用其实就是改变这两个寄存器的指向，故C语言编写的操作系统可以像调用函数那样调用执行用户程序。因此用户进程被加载到内存中后如同函数一样，仅仅是个指令区域，由于我们目前没有实现文件系统，前期我们用普通函数来代替用户程序，所以在main函数中我们新建了两个名为u_prog_a和u_prog_b的两个函数来作为进程执行的用户程序。在这两个程序中分别对test_var_a和test_var_b变量进行加1操作，由于用户态下的字符串打印函数我们还没实现，所以又新建两个内核线程k_thread_a和k_thread_b来打印这两个变量。

#include "print.h"  2 #include "debug.h"  3 #include "init.h"  4 #include "memory.h"  5 #include "thread.h"  6 #include "timer.h"  7 #include "list.h"  8 #include "interrupt.h"  9 #include "console.h" 10 #include "keyboard.h" 11 #include "ioqueue.h" 12 #include "process.h" 13  14 void k_thread_a(void *arg); 15 void k_thread_b(void *arg); 16 void u_prog_a(void); 17 void u_prog_b(void); 18 int test_var_a = 0, test_var_b = 0; 19 int main (void) 20 { 21     put_str("I am Kerneln"); 22     init_all(); 23  24     thread_start("k_thread_a", 31, k_thread_a, "argA "); 25     thread_start("k_thread_b", 31, k_thread_b, "argB "); 26     process_execute(u_prog_a, "user_prog_a"); 27     process_execute(u_prog_b, "user_prog_b"); 28     intr_enable(); 29  30     while (1); 31     return 0;   32 } 33  34 void u_prog_a(void) 35 { 36     while(1) { 37         test_var_a = *(int *)(0xc0006480); 38     } 39 } 40  41 void u_prog_b(void) 42 { 43     while(1) { 44         test_var_b++; 45     } 46 } 47  48 void k_thread_a(void *arg) 49 { 50     char *para = arg; 51     while (1) { 52         console_put_str("v_a:0x"); 53         console_put_int(test_var_a); 54         console_put_str("n"); 55     } 56 } 57  58 void k_thread_b(void *arg) 59 {  60     char *para = arg; 61     while (1) { 62         console_put_str("v_b:0x"); 63         console_put_int(test_var_b); 64         console_put_str("n"); 65     } 66 }

　　运行测试，可以看到基本正常。

　　

五、原书勘误
　　这个地方我当初做到这里这一章节时，死活调不通。通过打断点，可以看到进入进程后，中断表有明显的异常。
　　
　　在进程中，中断表的位置位于0x000063c0处，当然每个人的实际情况可能不太一样。总之明显不对，因为我们只给进程的页目录表映射了内核部分，很明显这个地址是没有被添加到页表中的。所以一旦发生了中断，CPU拿着这个中断表的地址去找中断描述符时就会报错，因为页表中没有记录这个位置的映射关系。

　　后面调试的时候发现其实是在实现中断代码那一章时，书上给的代码有误，原书第330页，如下:
　　
　　黄色部分的代码是罪魁祸首，我测试了一下，在我的系统中idt被存放在虚拟地址0xc00063c0处，对应到物理地址就是0x000063c0处。经过上图这种移位操作后，最终得到的地址变成了虚拟地址0x000063c0，可以发现高16位被舍掉了。在我们还没有实现进程的时候，在内核线程的页表中0x000063c0和0xc00063c0这两个虚拟地址都是映射到0x000063c0这个物理地址的，所以我们前面并不会报错。但是到了进程，在我们进程的页表中，只有0xc00063c0这个虚拟地址映射到0x000063c0这个物理地址，而0x000063c0这个虚拟地址是没有被添加映射关系的，所以才会一执行就报错。所以将代码修改成如下就好了：

　　uint64_t idt_operand = (sizeof(idt) - 1) | ((uint64_t)(uint32_t)idt << 16);

　　好了，本回合就到此结束了。这一章知识量还是比较多的，代码也是很长的，我也是回味了很久。预知后事如何，请看下回分解。