标签：struct thread void TSS 实验 真象 十九 uint32 vaddr
操作系统真象还原实验记录之实验十九：实现用户进程
1.相关基础知识
1.1 特权级（书P229）
cs寄存器的最后两位就是CPL，表示了cpu当前特权级。
对于访问数据段(type含有X可执行属性)
CPL和RPL<=DPL
对于访问非一致性代码段(type不含有X可执行属性)
只能平级，如果想执行跟高级的代码段，只能采用调用门，中断门，执行后CPL会改变成非一致性代码段的DPL。
特权级从低到高，调用门、中断门
从高到低,iret,retf
访问一致性代码段(type字段C为1)
数值上CPL>=一致性代码段的DPL
执行一致性代码段，CPL不会变成DPL，因此特权级仍然是与较低级一致的，故称一致性代码段。
1.调用门
call 和 jmp指令调用调用门
call有来有回，可以实现低向高特权转移，执行完毕后可以再通过retf指令实现由高向低。特权级由高向低转移只能使用iret和retf。
jmp有去无回，只能平级转移。
2.中断门
Int指令主动调用中断门，实现由低向高转移
比如Linux的系统调用
3.任务门
内含TSS选择子,用于任务切换
中断发生，中断向量号是任务门即完成调用，也可以call jmp调用。获得TSS选择子后完成根据TSS结构完成任务切换。
特权级高低转移不是任务切换，但需要用当前TSS里不同等级的栈。
1.2 call指令调用调用门完整过程
调用前特权级3，调用后特权级0
该调用门需要两个参数
要求数值上DPL_GATE>=CPL>=DPL_CODE
RPL<=DPL_GATE
这里的RPL是指提供的参数选择子。
进入内核后，这个选择子的RPL会被赋值为调用前的CPL即3
因此进入调用门后，就算CPL=0了，但是要访问的段的选择子仍然是之前的特权级3，仍然只能访问DPL=3的段。
(1)先将两个参数压入3特权级栈
(2)门描述符里的DPL=0，CPL=3，故在TSS里找到0特权级栈SS0,esp0
(3)检查ss0对应的栈段描述符DPL和TYPE是否通过。
(4)先找个地方保存ss_old和esp_old，然后将ss0赋值SS，esp0赋值esp，使用高特权级栈。
(5)压入ss_old,esp_old，然后根据参数个数，将3特权级栈中的两个参数复制到0特权级栈中。
(6)将cs_old,eip_old入栈
(7)最后将调用门描述符的选择子赋值CS，偏移量赋值EIP，执行调用门程序。
执行完调用门程序后，利用retf将特权级由高向低返回流程：
(1)执行retf时，先检查cs_old的RPL与当前CPL，判断转移后特权级是否改变，显然此例子由CPL=0>RPL=3,特权级检查通过。
(2)通过，弹出eip_old,cs_old
(3)reft+参数跳过参数，esp指向esp_old
(4)第一步已经判断了特权级发生了改变，所以弹出esp_old,ss_old。
(5)返回后，还要对段寄存器DS,ES,FS,GS的DPL检查，如果DPL<返回后的CPL，那么就要置0.
1.3 I/O特权级
eflags中由IOPL位，
只有当前CPL<IOPL,才能使用I/O指令in,out,cli,sti访问端口从而访问外设。
但是CPL<IOPL意味着可以用I/O指令访问所有端口。
每个端口都有一个编号，在TSS的I/O位图里
如果TSS的I/O位图哪一位是0，无论CPL和IOPL的大小
那么表示该位对应的端口都可以访问。
1.4 CPU原生支持的任务切换方式
任务门：支持任务切换
两个：一个是中断+任务门、一个是call或jmp+任务门和iretd
1.中断+任务门实现任务切换过程
通过中断获得中断向量号,该中断向量号对应的就是任务门。
iretd有两个作用：
eflags的第14位NT位为0，用于中断返回
NT为1，用于从新任务返回旧任务。
(1)中断发生时，CPU接收到中断向量号，在IDT索引到任务门描述符，
分析S和TYPE字段，确定是门描述符，开始进行任务切换，取出要切换的新任务的TSS选择子。
(2)再用新任务的TSS选择子在GDT索引TSS描述符
(3)判断描述符P位是否为1，为一表示TSS位于内存
(4)从TR获取旧任务TSS的地址，将CPU的当前任务状态（也就是寄存器,cr3,eflags等等）保存到旧任务的TSS
(5)将新任务TSS赋值到CPU（即各种寄存器中）
(6)使TR指向新TSS
(7)新TSS描述符B位置1
(8)将eflags的NT位置1
(9)旧任务TSS选择子写入新TSS"上一个任务的TSS指针"
(10)执行新任务
新任务执行完成后，调用iretd指令返回到旧任务，处理器检查NT位为1，开始返回工作
(1)eflags的NT位置0
(2)新TSS描述符B位置0
(3)当前任务状态写入TR指向的新TSS
(4)将“上一个任务的TSS指针“加载到TR，恢复上一个任务的状态
(5)执行旧任务。
2.通过jmp/call实现任务切换过程
任务门也可以在GDT中
call/jmp+TSS选择子或者call/jmp+任务门选择子，忽略偏移量。
其他步骤同理，也就是旧任务保存到旧TSS，新TSS赋值到CPU，iretd指令返回旧任务。
唯一多的一个步骤就是特权级检查
CPL和TSS选择子的RPL<=TSS描述符的DPL
1.5 Linux即本实验采用的任务切换方式
用TSS效率低
Linux一次性加载TSS和TR，初始化0特权级栈，然后不断修改同一个TSS的内容。
这次试验应该只是在一个任务特权级切换的时候，使用了TSS的0特权级栈，任务切换都是在同一个TSS修改，这样相比原生效率大大提升。
2.实验代码
2.1 main.c
#include "interrupt.h"
#include "init.h"
#include "thread.h"
#include "print.h"
#include "process.h"
#include "console.h"
void k_thread_a(void* );
void k_thread_b(void* );
void u_prog_a (void);
void u_prog_b (void);
int test_var_a=0, test_var_b=0;
int main(void) {
put_str("I am kernel\n");
init_all();
thread_start("k_thread_a", 31, k_thread_a, "argA ");
thread_start("k_thread_b", 8, k_thread_b, "argB ");
process_execute(u_prog_a, "user_prog_a");
process_execute(u_prog_b, "user_prog_b");
intr_enable();
while(1)
return 0;
}
void k_thread_a(void* arg){
char* para = arg;
while(1){
console_put_str("v_a:0x");
console_put_int(test_var_a);
}
}
void k_thread_b(void* arg){
char* para = arg;
while(1){
console_put_str("v_b:0x");
console_put_int(test_var_b);
}
}
void u_prog_a(void) {
while(1) {
test_var_a++;
}
}
void u_prog_b(void) {
while(1) {
test_var_b++;
}
}
main是进入内核的起点。
创建了两个进程，两个线程，均没有启动。
线程创建时在内核内存池申请了一页PCB，未申请页表。
进程创建时在内核内存池申请了一页PCB，一页页表，页表地址赋值给了PCB->pgdir,一页虚拟地址位图，赋值给了PCB->userprog_vaddr。
调度到用户进程时在start_process还在用户内存池创建了一页3特权级栈
注意，用户进程的物理地址使用的是用户内存池，用户内存池有自己的用户内存位图管理，见实验十三——内存管理系统。
进程和线程的启动依然是依靠时钟中断，时间片用完进行调度就绪队列的进程或线程。
所以最开始运行的仍然是主线程，用的页表都是分页实验设计好的主线程的页表，和线程实验一样，主进程页表位于，主线程会一直执行main函数的while(1)死循环，直到时间片用完。
主线程时间片用完，时钟中断处理程序进入schedule函数，
调度用户进程的话，先要将该用户进程的页表激活，同时还要修改tss的esp0，因为这次调度后该用户进程会上CPU，当再次时钟中断时会面临特权级从3向0的转变，CPU将会在进入时钟中断处理函数前取TSS的esp0，并且完成一系列栈的转移，1.2有详细步骤，这和调用门实现特权级从高向低转移原理一致，这属于Linux对于同一任务下特权级转移时利用TSS来进行栈的切换的方法。
也就是说，在切换到特权级为3的用户进程前，要更新页表，同时还要更新TSS的esp0(等于对应进程PCB页首地址)
调度工作完成后进入switch_to，利用ret配合thread_create的初始化执行kernel_thread函数，
然后执行start_process初始化cs为u_prog_a(其实thread_create已经赋值过一次了)等和esp赋值为3特权级栈
然后进入intr_exit，利用iretd实现特权级由0向3转换，
执行该用户进程u_prog_a函数。
接着调度线程的话，(这部分书上一句带过没有细讲)
进入时钟中断处理程序前，esp已经被换成了0特权级栈
process_activiate检测到是线程便不会更换页表，TSS的esp0也不会更新。
程序执行流是switch_to里执行ret，然后执行kernel_thread,然后执行k_thread_a(void* arg)。
很明显调度线程没有start_process的将cs修改成RPL=3，
也没有执行iretd指令，因此没有特权级转移，在时钟触发中断时，中断门描述符已经把0特权级选择子赋值给了cs，并且把TSS的esp0赋值给esp从而使用0特权级栈。
所以这个线程的k_thread_a(void* arg)执行在特权级为0下执行，put_char里的gs访问显存时特权级检查不会有问题。
这里还有一个点要注意：
调度进程的时候，执行iretd完成特权级3的用户进程的切换，同时还把DS,ES,FS,GS均置为了0，本次实验进入进程后的代码没有涉及这几个寄存器所以看不出来，但是再次调度线程的时候，gs已被置为0，无法用来访问显存了，所以put_char内部已经再次构造了RPL=0的显存段选择子。
其次这个线程将采用上次进程的页表来进行虚实地址转换，线程里用了put_char函数，会涉及到访问显存。
每个进程创建页表的函数create_page_dir()的原理是先在内核内存池申请一页作为页目录+页表
然后把主进程的页目录第768到1023个页目录项复制到自己的页表。
根据分页实验我们已经知道，
1.构造页目录时，分页实验的代码只构造了第0个页目录项和第768~1023个页目录项。其中第0和第768个目录项装的是第0个页表的首地址。第1023个页目录项装的是页目录的首地址。第769到1022个页目录项装的是第1到254个页表的首地址。
2.构造页表时，我们只构造了第0个页表中的前256个页表项。由于一块物理页4KB，因此分页机制下能访问的实地址只有低1MB，256*4KB=1MB。
根据第768项
也就是说两个进程的页表地址映射都是3GB~3GB+1MB 映射到实地址
0~1MB
因此线程的put_char函数访问显存不会出现任何问题，虽然不同进程下线程可能会访问到不同的页表中，但是这两个进程的地址映射规则是一致的。
2.2 process.c
#include "process.h"
#include "global.h"
#include "debug.h"
#include "memory.h"
#include "thread.h"
#include "list.h"
#include "tss.h"
#include "interrupt.h"
#include "string.h"
#include "console.h"
extern void intr_exit(void);
/* 构建用户进程初始上下文信息 */
void start_process(void* filename_) {
void* function = filename_;
struct task_struct* cur = running_thread();
cur->self_kstack += sizeof(struct thread_stack);
struct intr_stack* proc_stack = (struct intr_stack*)cur->self_kstack;
proc_stack->edi = proc_stack->esi = proc_stack->ebp = proc_stack->esp_dummy = 0;
proc_stack->ebx = proc_stack->edx = proc_stack->ecx = proc_stack->eax = 0;
proc_stack->gs = 0; // 用户态用不上,直接初始为0
proc_stack->ds = proc_stack->es = proc_stack->fs = SELECTOR_U_DATA;
proc_stack->eip = function; // 待执行的用户程序地址
proc_stack->cs = SELECTOR_U_CODE;
proc_stack->eflags = (EFLAGS_IOPL_0 | EFLAGS_MBS | EFLAGS_IF_1);
proc_stack->esp = (void*)((uint32_t)get_a_page(PF_USER, USER_STACK3_VADDR) + PG_SIZE) ;
proc_stack->ss = SELECTOR_U_DATA;
asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory");
}
/* 击活页表 */
void page_dir_activate(struct task_struct* p_thread) {
/********************************************************
* 执行此函数时,当前任务可能是线程。
* 之所以对线程也要重新安装页表, 原因是上一次被调度的可能是进程,
* 否则不恢复页表的话,线程就会使用进程的页表了。
********************************************************/
/* 若为内核线程,需要重新填充页表为0x100000 */
uint32_t pagedir_phy_addr = 0x100000; // 默认为内核的页目录物理地址,也就是内核线程所用的页目录表
if (p_thread->pgdir != NULL) { // 用户态进程有自己的页目录表
pagedir_phy_addr = addr_v2p((uint32_t)p_thread->pgdir);
}
/* 更新页目录寄存器cr3,使新页表生效 */
asm volatile ("movl %0, %%cr3" : : "r" (pagedir_phy_addr) : "memory");
}
/* 击活线程或进程的页表,更新tss中的esp0为进程的特权级0的栈 */
void process_activate(struct task_struct* p_thread) {
ASSERT(p_thread != NULL);
/* 击活该进程或线程的页表 */
page_dir_activate(p_thread);
/* 内核线程特权级本身就是0,处理器进入中断时并不会从tss中获取0特权级栈地址,故不需要更新esp0 */
if (p_thread->pgdir) {
/* 更新该进程的esp0,用于此进程被中断时保留上下文 */
update_tss_esp(p_thread);
}
}
/* 创建页目录表,将当前页表的表示内核空间的pde复制,
* 成功则返回页目录的虚拟地址,否则返回-1 */
uint32_t* create_page_dir(void) {
/* 用户进程的页表不能让用户直接访问到,所以在内核空间来申请 */
uint32_t* page_dir_vaddr = get_kernel_pages(1);
if (page_dir_vaddr == NULL) {
console_put_str("create_page_dir: get_kernel_page failed!");
return NULL;
}
/************************** 1 先复制页表 *************************************/
/* page_dir_vaddr + 0x300*4 是内核页目录的第768项 */
memcpy((uint32_t*)((uint32_t)page_dir_vaddr + 0x300*4), (uint32_t*)(0xfffff000+0x300*4), 1024);
/*****************************************************************************/
/************************** 2 更新页目录地址 **********************************/
uint32_t new_page_dir_phy_addr = addr_v2p((uint32_t)page_dir_vaddr);
/* 页目录地址是存入在页目录的最后一项,更新页目录地址为新页目录的物理地址 */
page_dir_vaddr[1023] = new_page_dir_phy_addr | PG_US_U | PG_RW_W | PG_P_1;
/*****************************************************************************/
return page_dir_vaddr;
}
/* 创建用户进程虚拟地址位图 */
void create_user_vaddr_bitmap(struct task_struct* user_prog) {
user_prog->userprog_vaddr.vaddr_start = USER_VADDR_START;
uint32_t bitmap_pg_cnt = DIV_ROUND_UP((0xc0000000 - USER_VADDR_START) / PG_SIZE / 8 , PG_SIZE);
user_prog->userprog_vaddr.vaddr_bitmap.bits = get_kernel_pages(bitmap_pg_cnt);
user_prog->userprog_vaddr.vaddr_bitmap.btmp_bytes_len = (0xc0000000 - USER_VADDR_START) / PG_SIZE / 8;
bitmap_init(&user_prog->userprog_vaddr.vaddr_bitmap);
}
/* 创建用户进程 */
void process_execute(void* filename, char* name) {
/* pcb内核的数据结构,由内核来维护进程信息,因此要在内核内存池中申请 */
struct task_struct* thread = get_kernel_pages(1);
init_thread(thread, name, default_prio);
create_user_vaddr_bitmap(thread);
thread_create(thread, start_process, filename);
thread->pgdir = create_page_dir();
enum intr_status old_status = intr_disable();
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);
intr_set_status(old_status);
}
包括的函数
start_process(void* filename_)
void process_activate(struct task_struct* p_thread)
刚开始的主线程特权级一直是0，被中断的是0特权级，进入中断不涉及特权级改变，不会从tss取esp0
如果是从3中断，那么就是特权级从3到0，进入中断意味着在此任务下特权级转变，cpu会自动从tss取esp0更新esp寄存器。
void page_dir_activate(struct task_struct* p_thread)
uint32_t* create_page_dir(void)
void create_user_vaddr_bitmap(struct task_struct* user_prog)
void process_execute(void* filename, char* name)
为用户进程在内核内存池申请了一页PCB，一页页表，在用户内存池申请了一页3特权级栈
2.3 thread.h（增加）
/* 进程或线程的pcb,程序控制块 */
struct task_struct {
uint32_t* self_kstack; // 各内核线程都用自己的内核栈
pid_t pid;
enum task_status status;
char name[TASK_NAME_LEN];
uint8_t priority;
uint8_t ticks; // 每次在处理器上执行的时间嘀嗒数
/* 此任务自上cpu运行后至今占用了多少cpu嘀嗒数,
* 也就是此任务执行了多久*/
uint32_t elapsed_ticks;
/* general_tag的作用是用于线程在一般的队列中的结点 */
struct list_elem general_tag;
/* all_list_tag的作用是用于线程队列thread_all_list中的结点 */
struct list_elem all_list_tag;
uint32_t* pgdir; // 进程自己页表的虚拟地址
struct virtual_addr userprog_vaddr; // 用户进程的虚拟地址
uint32_t stack_magic; // 用这串数字做栈的边界标记,用于检测栈的溢出
};
增加
struct virtual_addr userprog_vaddr; // 用户进程的虚拟地址
2.4 thread.c(增加)
void schedule() {
next->status= TASK_RUNNING;
process_activate(next);
switch_to(next);
}
2.5 global.h(增加)
// ---------------- GDT描述符属性 ----------------
#define DESC_G_4K 1
#define DESC_D_32 1
#define DESC_L 0 // 64位代码标记，此处标记为0便可。
#define DESC_AVL 0 // cpu不用此位，暂置为0
#define DESC_P 1
#define DESC_DPL_0 0
#define DESC_DPL_1 1
#define DESC_DPL_2 2
#define DESC_DPL_3 3
/*
代码段和数据段属于存储段，tss和各种门描述符属于系统段
s为1时表示存储段,为0时表示系统段.
*/
#define DESC_S_CODE 1
#define DESC_S_DATA DESC_S_CODE
#define DESC_S_SYS 0
#define DESC_TYPE_CODE 8 // x=1,c=0,r=0,a=0 代码段是可执行的,非依从的,不可读的,已访问位a清0.
#define DESC_TYPE_DATA 2 // x=0,e=0,w=1,a=0 数据段是不可执行的,向上扩展的,可写的,已访问位a清0.
#define DESC_TYPE_TSS 9 // B位为0,不忙
#define SELECTOR_K_CODE ((1 << 3) + (TI_GDT << 2) + RPL0)
#define SELECTOR_K_DATA ((2 << 3) + (TI_GDT << 2) + RPL0)
#define SELECTOR_K_STACK SELECTOR_K_DATA
#define SELECTOR_K_GS ((3 << 3) + (TI_GDT << 2) + RPL0)
/* 第3个段描述符是显存,第4个是tss */
#define SELECTOR_U_CODE ((5 << 3) + (TI_GDT << 2) + RPL3)
#define SELECTOR_U_DATA ((6 << 3) + (TI_GDT << 2) + RPL3)
#define SELECTOR_U_STACK SELECTOR_U_DATA
#define GDT_ATTR_HIGH ((DESC_G_4K << 7) + (DESC_D_32 << 6) + (DESC_L << 5) + (DESC_AVL << 4))
#define GDT_CODE_ATTR_LOW_DPL3 ((DESC_P << 7) + (DESC_DPL_3 << 5) + (DESC_S_CODE << 4) + DESC_TYPE_CODE)
#define GDT_DATA_ATTR_LOW_DPL3 ((DESC_P << 7) + (DESC_DPL_3 << 5) + (DESC_S_DATA << 4) + DESC_TYPE_DATA)
//--------------- TSS描述符属性 ------------
#define TSS_DESC_D 0
#define TSS_ATTR_HIGH ((DESC_G_4K << 7) + (TSS_DESC_D << 6) + (DESC_L << 5) + (DESC_AVL << 4) + 0x0)
#define TSS_ATTR_LOW ((DESC_P << 7) + (DESC_DPL_0 << 5) + (DESC_S_SYS << 4) + DESC_TYPE_TSS)
#define SELECTOR_TSS ((4 << 3) + (TI_GDT << 2 ) + RPL0)
struct gdt_desc {
uint16_t limit_low_word;
uint16_t base_low_word;
uint8_t base_mid_byte;
uint8_t attr_low_byte;
uint8_t limit_high_attr_high;
uint8_t base_high_byte;
};
#define EFLAGS_MBS (1 << 1) // 此项必须要设置
#define EFLAGS_IF_1 (1 << 9) // if为1,开中断
#define EFLAGS_IF_0 0 // if为0,关中断
#define EFLAGS_IOPL_3 (3 << 12) // IOPL3,用于测试用户程序在非系统调用下进行IO
#define EFLAGS_IOPL_0 (0 << 12) // IOPL0
#define NULL ((void*)0)
#define DIV_ROUND_UP(X, STEP) ((X + STEP - 1) / (STEP))
#define bool int
#define true 1
#define false 0
#define PG_SIZE 4096
2.6 tss.c
#include "tss.h"
#include "stdint.h"
#include "global.h"
#include "string.h"
#include "print.h"
#include "boot.inc"
/* 任务状态段tss结构 */
struct tss {
uint32_t backlink;
uint32_t* esp0;
uint32_t ss0;
uint32_t* esp1;
uint32_t ss1;
uint32_t* esp2;
uint32_t ss2;
uint32_t cr3;
uint32_t (*eip) (void);
uint32_t eflags;
uint32_t eax;
uint32_t ecx;
uint32_t edx;
uint32_t ebx;
uint32_t esp;
uint32_t ebp;
uint32_t esi;
uint32_t edi;
uint32_t es;
uint32_t cs;
uint32_t ss;
uint32_t ds;
uint32_t fs;
uint32_t gs;
uint32_t ldt;
uint32_t trace;
uint32_t io_base;
};
static struct tss tss;
/* 更新tss中esp0字段的值为pthread的0级线 */
void update_tss_esp(struct task_struct* pthread) {
tss.esp0 = (uint32_t*)((uint32_t)pthread + PG_SIZE);
}
/* 创建gdt描述符 */
static struct gdt_desc make_gdt_desc(uint32_t* desc_addr, uint32_t limit, uint8_t attr_low, uint8_t attr_high) {
uint32_t desc_base = (uint32_t)desc_addr;
struct gdt_desc desc;
desc.limit_low_word = limit & 0x0000ffff;
desc.base_low_word = desc_base & 0x0000ffff;
desc.base_mid_byte = ((desc_base & 0x00ff0000) >> 16);
desc.attr_low_byte = (uint8_t)(attr_low);
desc.limit_high_attr_high = (((limit & 0x000f0000) >> 16) + (uint8_t)(attr_high));
desc.base_high_byte = desc_base >> 24;
return desc;
}
/* 在gdt中创建tss并重新加载gdt */
void tss_init() {
put_str("tss_init start\n");
uint32_t tss_size = sizeof(tss);
memset(&tss, 0, tss_size);
tss.ss0 = SELECTOR_K_STACK;
tss.io_base = tss_size;
/* gdt段基址为0x900,把tss放到第4个位置,也就是0x900+0x20的位置 */
/* 在gdt中添加dpl为0的TSS描述符 */
*((struct gdt_desc*)0xc0000920) = make_gdt_desc((uint32_t*)&tss, tss_size - 1, TSS_ATTR_LOW, TSS_ATTR_HIGH);
/* 在gdt中添加dpl为3的数据段和代码段描述符 */
*((struct gdt_desc*)0xc0000928) = make_gdt_desc((uint32_t*)0, 0xfffff, GDT_CODE_ATTR_LOW_DPL3, GDT_ATTR_HIGH);
*((struct gdt_desc*)0xc0000930) = make_gdt_desc((uint32_t*)0, 0xfffff, GDT_DATA_ATTR_LOW_DPL3, GDT_ATTR_HIGH);
/* gdt 16位的limit 32位的段基址 */
uint64_t gdt_operand = ((8 * 7 - 1) | ((uint64_t)(uint32_t)0xc0000900 << 16)); // 7个描述符大小
asm volatile ("lgdt %0" : : "m" (gdt_operand));
asm volatile ("ltr %w0" : : "r" (SELECTOR_TSS));
put_str("tss_init and ltr done\n");
}
2.7 tss.h
#ifndef __USERPROG_TSS_H
#define __USERPROG_TSS_H
#include "thread.h"
void update_tss_esp(struct task_struct* pthread);
void tss_init(void);
#endif
2.8 memory.c增加
struct pool {
struct bitmap pool_bitmap; // 本内存池用到的位图结构,用于管理物理内存
uint32_t phy_addr_start; // 本内存池所管理物理内存的起始地址
uint32_t pool_size; // 本内存池字节容量
struct lock lock; // 申请内存时互斥
};
static void* vaddr_get(enum pool_flags pf, uint32_t pg_cnt) {
int vaddr_start = 0, bit_idx_start = -1;
uint32_t cnt = 0;
if (pf == PF_KERNEL) { // 内核内存池
bit_idx_start = bitmap_scan(&kernel_vaddr.vaddr_bitmap, pg_cnt);
if (bit_idx_start == -1) {
return NULL;
}
while(cnt < pg_cnt) {
bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);
}
vaddr_start = kernel_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
} else { // 用户内存池
struct task_struct* cur = running_thread();
bit_idx_start = bitmap_scan(&cur->userprog_vaddr.vaddr_bitmap, pg_cnt);
if (bit_idx_start == -1) {
return NULL;
}
while(cnt < pg_cnt) {
bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);
}
vaddr_start = cur->userprog_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
/* (0xc0000000 - PG_SIZE)做为用户3级栈已经在start_process被分配 */
ASSERT((uint32_t)vaddr_start < (0xc0000000 - PG_SIZE));
}
return (void*)vaddr_start;
}
/* 在用户空间中申请4k内存,并返回其虚拟地址 */
void* get_user_pages(uint32_t pg_cnt) {
lock_acquire(&user_pool.lock);
void* vaddr = malloc_page(PF_USER, pg_cnt);
if (vaddr != NULL) { // 若分配的地址不为空,将页框清0后返回
memset(vaddr, 0, pg_cnt * PG_SIZE);
}
lock_release(&user_pool.lock);
return vaddr;
}
/* 将地址vaddr与pf池中的物理地址关联,仅支持一页空间分配 */
void* get_a_page(enum pool_flags pf, uint32_t vaddr) {
struct pool* mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool;
lock_acquire(&mem_pool->lock);
/* 先将虚拟地址对应的位图置1 */
struct task_struct* cur = running_thread();
int32_t bit_idx = -1;
/* 若当前是用户进程申请用户内存,就修改用户进程自己的虚拟地址位图 */
if (cur->pgdir != NULL && pf == PF_USER) {
bit_idx = (vaddr - cur->userprog_vaddr.vaddr_start) / PG_SIZE;
ASSERT(bit_idx >= 0);
bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx, 1);
} else if (cur->pgdir == NULL && pf == PF_KERNEL){
/* 如果是内核线程申请内核内存,就修改kernel_vaddr. */
bit_idx = (vaddr - kernel_vaddr.vaddr_start) / PG_SIZE;
ASSERT(bit_idx > 0);
bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx, 1);
} else {
PANIC("get_a_page:not allow kernel alloc userspace or user alloc kernelspace by get_a_page");
}
void* page_phyaddr = palloc(mem_pool);
if (page_phyaddr == NULL) {
lock_release(&mem_pool->lock);
return NULL;
}
page_table_add((void*)vaddr, page_phyaddr);
lock_release(&mem_pool->lock);
return (void*)vaddr;
}
/* 得到虚拟地址映射到的物理地址 */
uint32_t addr_v2p(uint32_t vaddr) {
uint32_t* pte = pte_ptr(vaddr);
/* (*pte)的值是页表所在的物理页框地址,
* 去掉其低12位的页表项属性+虚拟地址vaddr的低12位 */
return ((*pte & 0xfffff000) + (vaddr & 0x00000fff));
}
static void mem_pool_init(uint32_t all_mem) {
/* 将位图置0*/
bitmap_init(&kernel_pool.pool_bitmap);
bitmap_init(&user_pool.pool_bitmap);
lock_init(&kernel_pool.lock);
lock_init(&user_pool.lock);
}
3.实验结果总结
3.1结果
3.2执行流esp寄存器的情况梳理
了解esp的动向，也就清楚了程序在各个时刻使用的是哪个栈。
- 主线程，esp=主线程PCB+size(即主线程0特权级栈)=0x9f000
- 主线程时钟中断，esp仍然是主线程0特权级栈 ，schedule检测到next是用户进程a含页表，tss.esp被赋值为next的0特权级栈。执行switch_to后，esp被赋值成了用户进程a的PCB最低地址,ret后执行start_process后iret，esp被赋值成了该进程3特权级栈，cpu来到用户进程a
- 用户进程a时钟中断切换用户线程a，调用中断门发现特权级将从3变0，esp最终被赋值成tss.esp0(即用户进程a的0特权级栈，含3特权级栈指针)，switch_to中esp切换用户线程a的PCB最低地址，pop、ret执行kernel，执行function，cpu来到用户线程a，特权级为0
- 用户线程a时钟中断切换用户线程b，调用中断门时特权级未转换，esp仍位于用户线程a的PCB内，switch_to内esp被用户线程b的PCB最低地址，pop、ret，执行kernel，执行function，cpu来到用户线程b。
- 用户线程b时钟中断切换用户进程a，中断进入schedule，检测到next为用户进程，故tss.esp0被赋值成用户进程a的0特权级栈，switch_to内esp被切换成上次用户进程a切换时的esp(即用户进程a的0特权级栈内)，ret时，根据1.2，0特权级栈顶发现eip_old的RPL=3，而当前cpl=0，所以0特权级栈会更换3特权级栈，由于用户进程a的0特权级栈含有上次进程a切换时的eip和3特权级栈指针，故esp最后又被赋值成用户进程a的3特权级栈，同时cpu来到用户进程a。
标签：struct,thread,void,TSS,实验,真象,十九,uint32,vaddr 来源： https://blog.csdn.net/mxy990811/article/details/118438994
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。