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

最新推荐文章于 2023-10-14 17:46:01 发布

徐步小兵

最新推荐文章于 2023-10-14 17:46:01 发布

阅读量2.1k

点赞数 6

分类专栏： Linux-0.11OS

本文链接：https://blog.csdn.net/weixin_43166958/article/details/104142054

版权

Linux-0.11OS 专栏收录该内容

16 篇文章 46 订阅

订阅专栏

实验环境：基于内核栈切换的进程切换
实验理论：
Linux-0.11操作系统实验4理论-用户级和内核级线程
 Linux-0.11操作系统实验4理论-内核级线程实现
实验本质：将 Linux 0.11 中采用的 TSS 切换部分去掉，取而代之的是基于堆栈的切换程序。具体的说，就是将 Linux 0.11 中的 switch_to实现去掉，写成一段基于堆栈切换的代码。

重写 `switch_to`

修改/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

该段代码完成的事情：

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

同时，注释掉原来switch_to宏函数，在/include/linux/sched.h文件中：
在这里插入图片描述

将重写的 `switch_to` 和 `schedule()` 函数接在一起

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

承上：基于堆栈的切换，要用到当前进程(current指向)与目标进程的PCB，当前进程与目标进程的内核栈等
- Linux 0.11 进程的内核栈和该进程的 PCB 在同一页内存上（一块 4KB 大小的内存），其中 PCB 位于这页内存的低地址，栈位于这页内存的高地址
启下：要将next传递下去，虽然 TSS(next)不再需要了，但是 LDT(next)仍然是需要的。

修改/include/linux/sched.h
之前的进程控制块(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, \
//......

修改/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)); // 修改添加的代码
}

修改现在的 `fork()`

对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;
}

最后还要考虑到如何从内核态返回到用户态. 最后返回的时候肯定是通过switch_to()函数的ret指令返回的, 但是由于copy_process()做了很多的栈的操作, cs和ip的值并不是在栈顶, 所以还需要一个first_return_from_kernel()函数来做进一步的返回操作.

first_return_from_kernel()函数已经在上面的system_call.s中添加，不再添加。

实验结果

在这里插入图片描述

实验问题

问题 1
针对下面的代码片段：

movl tss,%ecx
addl $4096,%ebx
movl %ebx,ESP0(%ecx)

回答问题：

（1）为什么要加 4096；
（2）为什么没有设置 tss 中的 ss0。

答：

（1）由于Linux 0.11进程的内核栈和该进程的PCB在同一页内存上（一块4KB大小的内存），其中PCB位于这页内存的低地址，栈位于这页内存的高地址；加4096就可以得到内核栈地址。

（2）tss.ss0是内核数据段，现在只用一个tss，因此不需要设置了。

问题 2
针对代码片段：

*(--krnstack) = ebp;
*(--krnstack) = ecx;
*(--krnstack) = ebx;
*(--krnstack) = 0;

回答问题：

（1）子进程第一次执行时，eax=？为什么要等于这个数？哪里的工作让 eax 等于这样一个数？
（2）这段代码中的 ebx 和 ecx 来自哪里，是什么含义，为什么要通过这些代码将其写到子进程的内核栈中？
（3）这段代码中的 ebp 来自哪里，是什么含义，为什么要做这样的设置？可以不设置吗？为什么？

答：

（1）eax =0。为了与父进程区分开 copy_process(），成功初始化进程copy_process后赋值eax得到。

（2）让eax=0 这段代码中的ebx和ecx来自copy_process()的形参，是段寄存器。fork函数决定，让父子的内核栈在初始化时完全一致.

（3）ebp是用户栈地址，一定要设置，不设置子进程就没有用户栈了.

问题 3
为什么要在切换完 LDT 之后要重新设置 fs=0x17？而且为什么重设操作要出现在切换完 LDT 之后，出现在 LDT 之前又会怎么样？

答：

这两句代码的含义是重新取一下段寄存器fs的值，这两句话必须要加，也必须要出现在切换完LDT之后，这是因为通过fs访问进程的用户态内存，LDT切换完成就意味着切换了分配给进程的用户态内存地址空间，所以前一个fs指向的是上一个进程的用户态内存，而现在需要执行下一个进程的用户态内存，所以就需要用这两条指令来重取fs。出现在LDT之前访问的就还是上一个进程的用户态内存

参考链接：

https://www.cnblogs.com/XiangfeiAi/p/4758401.html

https://blog.csdn.net/a634238158/article/details/100118927

https://blog.csdn.net/weixin_41761478/article/details/99777145

徐步小兵

关注

6
点赞
踩
14

收藏

觉得还不错? 一键收藏
9
评论
Linux-0.11操作系统实验4-基于内核栈切换的进程切换

实验环境：基于内核栈切换的进程切换实验本质：将 Linux 0.11 中采用的 TSS 切换部分去掉，取而代之的是基于堆栈的切换程序。具体的说，就是将 Linux 0.11 中的 switch_to实现去掉，写成一段基于堆栈切换的代码。重写 switch_to修改/kernel/system_call.s：.globl system_call,sys_fork,timer_interrup...
复制链接

扫一扫