操作系统实验04-基于内核栈切换的进程切换

实验内容

• 编写汇编程序 switch_to：
• 完成主体框架；
• 在主体框架下依次完成 PCB 切换、内核栈切换、LDT 切换等；
• 修改 fork()，由于是基于内核栈的切换，所以进程需要创建出能完成内核栈切换的样子。
• 修改 PCB，即 task_struct 结构，增加相应的内容域，同时处理由于修改了 task_struct 所造成的影响。
• 用修改后的 Linux 0.11 仍然可以启动、可以正常使用。

实验步骤

1.修改/kernel/system_call.s文件

.globl system_call,sys_fork,timer_interrupt,sys_execve
.globl hd_interrupt,floppy_interrupt,parallel_interrupt
.globl device_not_available, coprocessor_error
# 以上是原代码部分，以下是需要新建的代码

# system_call.s
# 汇编语言中定义的方法可以被其他调用需要
.globl switch_to
.globl first_return_from_kernel
# 硬编码改变 these are offsets into the task-struct

ESP0 = 4
KERNEL_STACK = 12

state	= 0		# these are offsets into the task-struct.
counter	= 4
priority = 8
kernelstack = 12
signal	= 16
sigaction = 20		# MUST be 16 (=len of sigaction)
blocked = (37*16)

switch_to:
    pushl %ebp
    movl %esp,%ebp
    pushl %ecx
    pushl %ebx
    pushl %eax
    movl 8(%ebp),%ebx
    cmpl %ebx,current
    je 1f
# switch_to PCB
    movl %ebx,%eax
	xchgl %eax,current
# rewrite TSS pointer
    movl tss,%ecx
    addl $4096,%ebx
    movl %ebx,ESP0(%ecx)
# switch_to system core stack
    movl %esp,KERNEL_STACK(%eax)
    movl 8(%ebp),%ebx
    movl KERNEL_STACK(%ebx),%esp
# switch_to LDT
	movl 12(%ebp), %ecx
    lldt %cx
    movl $0x17,%ecx
	mov %cx,%fs
# nonsense
    cmpl %eax,last_task_used_math 
    jne 1f
    clts

1:    popl %eax
    popl %ebx
    popl %ecx
    popl %ebp
ret

.align 2
first_return_from_kernel: 
    popl %edx
    popl %edi
    popl %esi
    pop %gs
    pop %fs
    pop %es
    pop %ds
    iret

该段代码完成的工作如下：
1.push l %ebp
首先在汇编中处理栈帧，即处理 ebp 寄存器
2.cmpl %ebx,current
接下来要取出表示下一个进程 PCB 的参数，并和 current 做一个比较，如果等于 current，则什么也不用做。不等于 current，就开始进程切换。
3.switch_to PCB完成 PCB 的切换
ebx是从参数中取出来的下一个进程的 PCB 指针，经过两条指令以后，eax 指向现在的当前进程，ebx指向下一个进程，全局变量 current 也指向下一个进程。
4.rewrite TSS pointerTSS 中的内核栈指针的重写
中断处理时需要寻找当前进程的内核栈，否则就不能从用户栈切到内核栈(中断处理没法完成)，内核栈的寻找是借助当前进程TSS中存放的信息来完成的。
5.switch_to system core stack内核栈的切换
将寄存器 esp（内核栈使用到当前情况时的栈顶位置）的值保存到当前 PCB 中，再从下一个 PCB 中的对应位置上取出保存的内核栈栈顶放入 esp寄存器，这样处理完以后，再使用内核栈时使用的就是下一个进程的内核栈了。
6.switch_to LDTLDT的切换
指令 movl 12(%ebp),%ecx 负责取出对应 LDT(next)的那个参数，指令 lldt %cx 负责修改 LDTR 寄存器，一旦完成了修改，下一个进程在执行用户态程序时使用的映射表就是自己的 LDT 表了，地址空间实现了分离。
最后，通过FS操作系统才能访问进程的用户态内存。这里LDT切换完成意味着切换到了新的用户态地址空间，所以需要重置FS。
代码截图如下（部分）:

2.修改/include/linux/sched.h文件

注释掉原来switch_to宏函数，截图如下：

基于堆栈的切换程序要做到承上启下：

• 承上：基于堆栈的切换，要用到当前进程(current指向)与目标进程的PCB，当前进程与目标进程的内核栈等
  Linux 0.11 进程的内核栈和该进程的 PCB 在同一页内存上（一块 4KB 大小的内存），其中 PCB 位于这页内存的低地址，栈位于这页内存的高地址
• 启下：要将next传递下去，虽然 TSS(next)不再需要了，但是 LDT(next)仍然是需要的。
  之前的进程控制块(pcb)中是没有保存内核栈信息的寄存器的，所以需要在sched.h中的task_struct(也就是pcb)中添加kernelstack。

struct task_struct {
/* these are hardcoded - don't touch */
	long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
	long counter;
	long priority;
	//新增kernelstack
	long kernelstack;
	long signal;
	struct sigaction sigaction[32];
	//......

代码截图如下：

由于这里将 PCB 结构体的定义改变了，所以在产生 0 号进程的 PCB 初始化时也要跟着一起变化，需要修改 #define INIT_TASK，即在 PCB 的第四项中增加关于内核栈栈指针的初始化。

#define INIT_TASK 
/* state etc */	{ 0,15,15,PAGE_SIZE+(long)&init_task, 
//......

代码截图如下:

3.修改/kernel/sched.c文件

// 添加的代码,定义tss
struct task_struct *tss= &(init_task.task.tss); 

void schedule(void)
{
	int i,next,c;
	struct task_struct ** p;
	struct task_struct *pnext = NULL; // 添加的代码,赋值初始化任务的指针

/* check alarm, wake up any interruptible tasks that have got a signal */

	for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
		if (*p) {
			if ((*p)->alarm && (*p)->alarm < jiffies) {
					(*p)->signal |= (1<<(SIGALRM-1));
					(*p)->alarm = 0;
				}
			if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
			(*p)->state==TASK_INTERRUPTIBLE)
					(*p)->state=TASK_RUNNING;			
		}

/* this is the scheduler proper: */

	while (1) {
		c = -1;
		next = 0;
        // 添加的代码. 如果系统没有进程可以调度时传递进去的是一个空值，系统宕机，
        // 所以加上这句，这样就可以在next=0时不会有空指针传递
		pnext = task[next];
		
		i = NR_TASKS;
		p = &task[NR_TASKS];
		while (--i) {
			if (!*--p)
				continue;
			if ((*p)->state == TASK_RUNNING && (*p)->counter> c)
				c = (*p)->counter, next = i, pnext=*p;// 修改添加的代码
		}
		if (c) break;
		for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
			if (*p)
				(*p)->counter = ((*p)->counter >> 1) +
						(*p)->priority;
	}
	//switch_to(next);
	switch_to(pnext, _LDT(next)); // 修改添加的代码
}

更改截图如下：

4.修改fork.c文件

对fork()的修改就是对子进程的内核栈的初始化，在fork()的核心实现copy_process中，p = (struct task_struct) get_free_page();用来完成申请一页内存作为子进程的PCB，而p指针加上页面大小就是子进程的内核栈位置. 所以需要再定义一个指针变量krnstack, 并将其初始化为内核栈顶指针, 然后再根据传递进来的参数把前一个进程的PCB中各种信息都保存到当前栈中。
可以将原代码copy_process函数注释，替换为以下：

//fork.c
//6th
extern void first_return_from_kernel(void);

//fork.c copy_process()
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	struct task_struct *p;
	int i;
	struct file *f;
    long * krnstack;
//1st
    p = (struct task_struct *) get_free_page();
    if (!p)
        return -EAGAIN;
    task[nr] = p;
    *p = *current;    /* NOTE! this doesn't copy the supervisor stack */
    p->state = TASK_UNINTERRUPTIBLE;
    p->pid = last_pid;
    p->father = current->pid;
    p->counter = p->priority;
    p->signal = 0;
    p->alarm = 0;
    p->leader = 0;        /* process leadership doesn't inherit */
    p->utime = p->stime = 0;
    p->cutime = p->cstime = 0;
    p->start_time = jiffies;
    if (last_task_used_math == current)
        __asm__("clts ; fnsave %0"::"m" (p->tss.i387));
    if (copy_mem(nr,p)) {
        task[nr] = NULL;
        free_page((long) p);
        return -EAGAIN;
    }
//2nd
    krnstack = (long *) (PAGE_SIZE + (long) p);
    *(--krnstack) = ss & 0xffff;
    *(--krnstack) = esp;
    *(--krnstack) = eflags;
    *(--krnstack) = cs & 0xffff;
    *(--krnstack) = eip;

    *(--krnstack) = ds & 0xffff; 
    *(--krnstack) = es & 0xffff; 
    *(--krnstack) = fs & 0xffff; 
    *(--krnstack) = gs & 0xffff;
    *(--krnstack) = esi; 
    *(--krnstack) = edi; 
    *(--krnstack) = edx;
//3rd
	*(--krnstack) = first_return_from_kernel;
//4th
    *(--krnstack) = ebp;
    *(--krnstack) = ecx;
    *(--krnstack) = ebx;
    *(--krnstack) = 0;
//5th
	p->kernelstack = krnstack;
	
    for (i=0; i<NR_OPEN;i++)
        if ((f=p->filp[i]))
            f->f_count++;
    if (current->pwd)
        current->pwd->i_count++;
    if (current->root)
        current->root->i_count++;
    if (current->executable)
        current->executable->i_count++;
    set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
    set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
    p->state = TASK_RUNNING;    /* do this last, just in case */
    return last_pid;
}

5.验证结果：

经过验证，用修改后的 Linux 0.11 仍然可以启动、可以正常使用。