这是 tss 的结构
struct tss {
uint_32 last_tss;
uint_32* esp0;
uint_32 ss0;
uint_32* esp1;
uint_32 ss1;
uint_32* esp2;
uint_32 ss2;
uint_32 cr3;
uint_32 (*eip)(void);
uint_32 eflags;
uint_32 eax;
uint_32 ecx;
uint_32 edx;
uint_32 ebx;
uint_32 esp;
uint_32 ebp;
uint_32 esi;
uint_32 edi;
uint_32 es;
uint_32 cs;
uint_32 ss;
uint_32 ds;
uint_32 fs;
uint_32 gs;
uint_32 ldt;
uint_32 io_pos;
};
static struct tss tss;
虽然我们只声明了一个 tss ，但问题不大。事实上，我们并不采用cpu自带的多任务切换来实现用户进程，因此只要一个 tss 即可。这个 tss 作为“当前”进程的任务状态段存在，存在的主要意义在于当前进程用户态和内核态之间的切换。
从用户态转到内核态时，CPU会从TSS内读取并加载ss和esp0，使用pcb内的内核栈。tss 中的ss往往不变，而esp0 需要根据当前用户进程变化，方便它切换至相应内核态pcb的栈。
因此，这么大个 tss ，在我们的实现里，只关心里面的 esp0。esp0在当前pcb的顶端。
void update_tss_esp(struct task_struct* pthread) {
tss.esp0 = (uint_32*)((uint_64)(uint_32)pthread + PAGESIZE);
}
在gdt中创建tss描述符、用户数据段和代码段。
重新加载gdt和tss
0xc0000620 的由来: 0x600 是内核被加载的地方，前面的是已经虚拟构成的内核gdt表项。
这是原来的 GDT。
;----------------------------------------------------------
SECTION loader vstart=LOADER_BASE_ADDR
LOADER_STACK_TOP equ LOADER_BASE_ADDR
GDT_NULL dd 0x00
dd 0x00
CODE_SEG dd 0x0000ffff
dd DESC_CODE_HIGH4
DATA_SEG dd 0x0000ffff
dd DESC_DATA_HIGH4
VIDIO_SEG dd 0x80000007
dd DESC_VIDEO_HIGH4
GDT_SIZE equ $-GDT_NULL
GDT_LIMIT equ GDT_SIZE-1
times 60 dq 0 ;预留空位
这里形成的是用户的一些描述符。
设置了 TSS 的一些必要的表项。
void tss_init(void)
{
put_str("tss init start\n");
uint_32 tss_size = sizeof(tss);
tss.last_tss = 0;
tss.io_pos = tss_size;
tss.ss0 = SELECTOR_K_STACK;
update_tss_esp(running_thread());
// tss 描述符
*((struct gdt_desc*)0xc0000620) = form_gdt_desc(&tss, \
tss_size-1, \
TSS_ATTR_LOW, \
TSS_ATTR_HIGH);
// 用户代码段 描述符
*((struct gdt_desc*)0xc0000628) = form_gdt_desc((void*)0, \
0xfffff, \
USRCODE_ATTR_LOW, \
USRCODE_ATTR_HIGH);
// 用户数据段 描述符
*((struct gdt_desc*)0xc0000630) = form_gdt_desc((void*)0, \
0xfffff, \
USRDATA_ATTR_LOW,
USRDATA_ATTR_HIGH);
uint_64 gdt_op = ((7*8-1) | ((uint_64)(uint_32)0xc0000600)<<16);
asm volatile("lgdt %0"::"m"(gdt_op));
asm volatile("ltr %w0"::"r"(SELECTOR_TSS));
put_str("tss init done\n");
}
本章的内容可分为两块：初始化和执行
void process_execute(char* name,void* filename)
{
void* pcb_addr = get_kernel_pages(1);
struct task_struct* pcb = (struct task_struct*)pcb_addr;
init_thread(pcb,name,DEFALT_PRI);
// 初始化
create_page_dir(pcb);
usr_vaddr_init(pcb);
// 执行
thread_create(pcb,start_process,filename);
enum intr_status old_status = intr_disable();
list_append(&all_thread_list,&pcb->all_list_tag);
list_append(&thread_ready_list,&pcb->wait_tag);
intr_set_status(old_status);
}
用户进程和内核线程的第一个不同之处在于，它们有自己的4GB虚拟内存。具体来说就是，有自己的页目录表和页表，还有自己管理的一块虚拟内存。
PCB 的内容
struct task_struct {
uint_32* kstack_p;
char name[20];
pid_t pid;
struct list_elm wait_tag;
struct list_elm all_list_tag;
uint_32 ticks;
uint_32 elapsed_ticks;
enum task_status status;
uint_32 priority;
/************************************************/
void* pdir;
struct virt_addr usrprog_vaddr;
/************************************************/
uint_32 kmagic;
};
页目录表和虚拟内存池，这两个参数在pcb是存在的。只不过我们以前的是线程，用不上。
这里创建进程就需要在pcb中记录这些信息。
换言之也就是，初始化进程 = 初始化线程 + 初始化进程特有参数并记录至pcb
创造用户进程特有的页目录表，它是用户拥有独立4GB虚拟地址的证明。3GB以上的内核部分是共享的，所以初始化时要从内核页目录表那复制过来，以使第0x300个及之后的pde指向相同的页表。页目录表的最后一项指向自己。
void create_page_dir(struct task_struct* pcb)
{
uint_32* page_dir_vaddr = get_kernel_pages(1);
memcpy((void*)((uint_32)page_dir_vaddr+0x300*4),(void*)0xfffffc00,255*4);
page_dir_vaddr[1023] = v2p(page_dir_vaddr)|PAGE_RW_W|PAGE_US_U|PAGE_P;
pcb->pdir = page_dir_vaddr;
}
用户进程需要自己管理自己的虚拟内存。
虚拟地址起始处：#define USR_VADDR_START 0x8048000
如果你观察Linux下可执行文件的起始位置，可以发现 Entry point address 往往在 0x8048000 左右。当然，你在编译时，得加两个参数，一个是-m32，因为咱现在是32位系统；还有一个是-no-pie，如果使用pie的话，没有绝对地址引用所以每次加载的地址也不尽相同。
void usr_vaddr_init(struct task_struct* pcb)
{
uint_32 btmp_pgsize = DIV_ROUND_UP((0xc0000000 - USR_VADDR_START)/PAGESIZE/8,PAGESIZE);
struct virt_addr* usr_vaddr = &pcb->usrprog_vaddr;
// 指定虚拟地址起始处
usr_vaddr->vaddr_start = USR_VADDR_START;
// 初始化vaddr->btmp
usr_vaddr->btmp.bits = get_kernel_pages(btmp_pgsize);
usr_vaddr->btmp.map_size = (0xc0000000-USR_VADDR_START)/PAGESIZE/8;
bit_init(&pcb->usrprog_vaddr.btmp);
}
初始化完了，执行时schedule()必须做相应的 process_activate。
void schedule(void)
{
struct task_struct* cur = running_thread();
if (cur->ticks == 0)
{
cur->ticks = cur->priority;
cur->status = TASK_READY;
list_append(&thread_ready_list,&cur->wait_tag);
}
if (list_empty(&thread_ready_list)) thread_unblock(idle_pcb);
struct list_elm* next_ready_tag = list_pop(&thread_ready_list);
struct task_struct* next = mem2entry(struct task_struct,next_ready_tag,wait_tag);
process_activate(next);
next->status = TASK_RUNNING;
switch_to(cur,next);
}
激活cr3，调整tss内esp0的内容。正式指定用户虚拟地址和内核栈。
void process_activate(struct task_struct* pcb)
{
page_dir_activate(pcb);
update_tss_esp(pcb);
}
void page_dir_activate(struct task_struct* pcb)
{
uint_32 pdir_paddr;
if (pcb->pdir == NULL) {
pdir_paddr = 0x100000;
} else {
pdir_paddr = v2p(pcb->pdir);
}
asm volatile("movl %0,%%cr3"::"r"(pdir_paddr));
}
kernel_thread 执行函数 start_process。
用户进程和内核线程第二个不同在于特权级的差异。用户进程特权级为3，目前特权级为0，ret是不能从高特权级切换到低特权级的。因此，这里我们需要使用 iret 假装从中断返回 。在这个过程中，设置好精心准备的 intr_stack 内容然后弹出恢复寄存器映像。
void start_process(void* filename)
{
void* func = filename;
struct task_struct* cur = running_thread();
cur->kstack_p += sizeof(struct thread_stack);
struct intr_stack* intr = (struct intr_stack*)cur->kstack_p;
intr->vec_no = 0;
intr->esi = intr->edi = intr->ebp = intr->esp_dump = 0;
intr->eax = intr->ebx = intr->ecx = intr->edx = 0;
intr->gs = 0;
intr->ss = intr->ds = intr->es = intr->gs = SELECTOR_U_DATA;
intr->cs = SELECTOR_U_CODE;
intr->eip = func;
intr->eflags = (EFLAG_MBS | EFALG_IOPL_0 | EFLAG_IF_1);
intr->esp = get_a_page(PF_USER,USR_STACK_VADDR);
asm volatile("movl %0,%%esp;jmp int_exit;"::"g"((uint_32)intr):"memory");
}
intr_stack初始化
用户进程不能访问显存，gs=0。
vec_no没有什么作用，不用设置。
作为一个进程的开始，没有任何计算发生，所以8个通用寄存器都置为0即可。
eflags 的IOPL位为0，CPL <= IOPL时当前代码段才能执行I/O操作，要求用户程序默认情况下外设端口不开启。进程需要开中断，时间片到了好换下去，IF位为1。MBS 固定为1。
要为用户进程申请一块地方作为栈， 令esp指向那里。#define USR_STACK_VADDR (0xc0000000-1000)
struct intr_stack{
uint_32 vec_no;
uint_32 edi;
uint_32 esi;
uint_32 ebp;
uint_32 esp_dump;
uint_32 ebx;
uint_32 edx;
uint_32 ecx;
uint_32 eax;
uint_32 gs;
uint_32 fs;
uint_32 es;
uint_32 ds;
uint_32 err_code;
void (*eip)(void);
uint_32 cs;
uint_32 eflags;
void* esp;
uint_32 ss;
};
参考资料：
操作系统真象还原
linker script 简单教学
