实验名称：基于内核栈切换的进程切换

实验日期：2021年5月27号

班级：物联网193班

姓名：邹胡健

学号：1930110718

一、实验目的

• 深入理解进程和进程切换的概念；
• 综合应用进程、CPU 管理、PCB、LDT、内核栈、内核态等知识解决实际问题；
• 开始建立系统认识。

二、实验环境

• oslab实验室

三、实验内容

• 现在的 Linux 0.11 采用 TSS（后面会有详细论述）和一条指令就能完成任务切换，虽然简单，但这指令的执行时间却很长，在实现任务切换时大概需要 200 多个时钟周期。

• 而通过堆栈实现任务切换可能要更快，而且采用堆栈的切换还可以使用指令流水的并行优化技术，同时又使得 CPU 的设计变得简单。所以无论是 Linux 还是 Windows，进程/线程的切换都没有使用 Intel 提供的这种 TSS 切换手段，而都是通过堆栈实现的。

• 本次实践项目就是将 Linux 0.11 中采用的 TSS 切换部分去掉，取而代之的是基于堆栈的切换程序。具体的说，就是将 Linux 0.11 中的 switch_to 实现去掉，写成一段基于堆栈切换的代码。

• 本次实验包括如下内容：

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

四、实验报告

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

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

回答问题：

• （1）为什么要加 4096；

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

• （2）为什么没有设置 tss 中的 ss0。

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

问题 2 针对代码片段：

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

回答问题：

• （1）子进程第一次执行时，eax=？为什么要等于这个数？哪里的工作让 eax 等于这样一个数？

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

• （2）这段代码中的 ebx 和 ecx 来自哪里，是什么含义，为什么要通过这些代码将其写到子进程的内核栈中？

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

• （3）这段代码中的 ebp 来自哪里，是什么含义，为什么要做这样的设置？可以不设置吗？为什么？

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

问题 3

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

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

五、评分标准

• switch_to(kernal/system_call.s)，40%
• fork.c，30%
• sched.h 和 sched.c，10%
• 实验报告，20%

六、实验提示

• 本次实验将 Linux 0.11 中采用的 TSS 切换部分去掉，取而代之的是基于堆栈的切换程序。具体的说，就是将 Linux 0.11 中的 switch_to （在 kernal/system_call.s 中）实现去掉，写成一段基于堆栈切换的代码。

七、实验记录

• 解压实验环境

cd ~/oslab
tar  -zxvf hit-oslab-linux-20110823.tar.gz  -C  /home/shiyanlou
copy

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

    movl %ebx,%eax
    xchgl %eax,current

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

    movl %esp,KERNEL_STACK(%eax)
    movl 8(%ebp),%ebx
    movl KERNEL_STACK(%ebx),%esp

    movl 12(%ebp), %ecx
    lldt %cx
    movl $0x17,%ecx
    mov %cx,%fs

    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
copy

• 修改/include/linux/sched.h文件 注释掉switch to函数

• 修改/kernel/sched.c中的schedule()函数 注释掉原来switch_to宏函数

• 在sched.h中的task_struct(也就是pcb)中添加kernelstack。

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

• 修改 #define INIT_TASK，即在 PCB 的第四项中增加关于内核栈栈指针的初始化

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

• 修改fork.c文件

//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;
}
copy

• 编译通过

• 运行

八、实验结果分析

文件修改，汇编程序 switch_to，完成主体框架及在框架下的各种操作均正确

九、实验总结

本次实践项目就是将 Linux 0.11 中采用的 TSS 切换部分去掉，取而代之的是基于堆栈的切换程序。具体的说，就是将 Linux 0.11 中的 switch_to 实现去掉，写成一段基于堆栈切换的代码。这次实验，让我理解了进程和进程切换的概念，能够成功解决实际问题，加深对操作系统知识的理解。