linux内核分析：进程切换机制

“陈涛 + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000 ”

这次作业主要运行一个小程序来演示linux内核对于进程切换的机制。这个小程序采用是时间轮转来切换不同进程（包括保存上下文和加载进程）

一、mypcb.h—->关于进程控制块PCB的数据结构

#define MAX_TASK_NUM 4 
#define KERNEL_STACK_SIZE 1024*2 # unsigned long
/* CPU-specific state of this task */
struct Thread {
    unsigned long       ip;
    unsigned long       sp;
};

typedef struct PCB{
    int pid;
    volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
    unsigned long stack[KERNEL_STACK_SIZE];
    /* CPU-specific state of this task */
    struct Thread thread;
    unsigned long   task_entry;
    struct PCB *next;
}tPCB;

void my_schedule(void);

上述程序定义pcb，其包含了进程id，进程状态，进程的堆栈，进程的eip和esp，进程的入口地址，以及下一个进程的地址。还设置了进程数目是4个。

二、mymain.c—->对每个进程初始化

tPCB task[MAX_TASK_NUM];
tPCB * my_current_task = NULL;
volatile int my_need_sched = 0;

先是定义进程数组，当前运行进程是谁、是否需要切换（0代表不切换、1代表切换）

void __init my_start_kernel(void)
{
    int pid = 0;
    int i;
    /* Initialize process 0*/
    task[pid].pid = pid;
    task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped */
    task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];
    /*fork more process */
    for(i=1;i<MAX_TASK_NUM;i++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));
        task[i].pid = i;
        task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];
    *(task[i].thread.sp - 1) = task[i].thread.sp;
    task[i].thread.sp -= 1;
        task[i].next = task[i-1].next;
        task[i-1].next = &task[i];
    }
    /* start process 0 by task[0] */
    pid = 0;
    my_current_task = &task[pid];
    asm volatile(
        "movl %1,%%esp\n\t"     /* set task[pid].thread.sp to esp */
        "pushl %1\n\t"          /* push ebp */
        "pushl %0\n\t"          /* push task[pid].thread.ip */
        "ret\n\t"               /* pop task[pid].thread.ip to eip */
        "popl %%ebp\n\t"
        : 
        : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   /* input c or d mean %ecx/%edx*/
    );
}   

for循环之前，先是设置0号进程id，运行状态、入口地址、eip、esp、以及下一个进程（0号进程设置下一个进程依然是自己）
for中，先完全复制一份0号进程，然后对其中的值进行修改（设置id、初始化esp、压栈保存esp、采用尾插法加入到进程链）
for后，通过汇编来启动0号进程。先把当前任务标志设置为0号进程。
(汇编的参数不列出来)
“movl %1,%%esp\n\t” ：把0号进程的esp赋给esp
“pushl %1\n\t” ： 把0号进程的esp压栈
“pushl %0\n\t” “ret\n\t” ： 结合起来使用，间接修改eip
“popl %%ebp\n\t” ： 把esp的值赋给ebp，来达到初始化栈

  void my_process(void)
{
    int i = 0;
    while(1)
    {
        i++;
        if(i%10000000 == 0)
        {
            printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);
            if(my_need_sched == 1)
            {
                my_need_sched = 0;
                my_schedule();
            }
            printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
        }     
    }
}

运行进程时，会查看my_need_sched的值是否为1，表示进程是否要切换。

三、myinterrupt.c—->进程切换机制实现

void my_timer_handler(void)
{
#if 1
    if(time_count%1000 == 0 && my_need_sched != 1)
    {
        printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
        my_need_sched = 1;
    } 
    time_count ++ ;  
#endif
    return;     
}

相当于计时器，决定什么时候进行进程切换，即把my_need_sched置为1。从而实现时间轮转的进程调度。

void my_schedule(void)
{
    tPCB * next;
    tPCB * prev;

    if(my_current_task == NULL 
        || my_current_task->next == NULL)
    {
        return;
    }
    printk(KERN_NOTICE ">>>my_schedule<<<\n");
    /* schedule */
    next = my_current_task->next;
    prev = my_current_task;
    if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
    {        
        my_current_task = next; 
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);  
        /* switch to next process */
        asm volatile(   
            "pushl %%ebp\n\t"       /* save ebp */
            "movl %%esp,%0\n\t"     /* save esp */
            "movl %2,%%esp\n\t"     /* restore  esp */
            "movl $1f,%1\n\t"       /* save eip */ 
            "pushl %3\n\t" 
            "ret\n\t"               /* restore  eip */
            "1:\t"                  /* next process start here */
            "popl %%ebp\n\t"
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
            : "m" (next->thread.sp),"m" (next->thread.ip)
        ); 
    }  
    return; 
}

第一个if,当前进程或下一个进程为null，结束，来防止程序出错。
pre当前运行进程，即将为切换。next为即将要运行的进程。
第二个if：先查看next进程是否是运行状态。若是，通过汇编来进行上下文的保存以及进程切换
其中：(汇编的参数不列出来)
    "pushl %%ebp\n\t" :保存pre的ebp
    "movl %%esp,%0\n\t":保存pre的esp到内存的prev->thread.sp中
    "movl %2,%%esp\n\t" :加载next的esp
    "movl $1f,%1\n\t" : 保存pre的eip到内存的prev->thread.ip
     "pushl %3\n\t"  "ret\n\t" :一起使用，把next的eip压栈，在出栈保存在eip，从而间接修改eip
     "1:\t" :1为标记，从next所中断的地方开始执行。
     "popl %%ebp\n\t":加载next的ebp

四、运行结果

在实验楼，执行：
cd LinuxKernel/linux-3.9.4
rm -rf mykernel
patch -p1 < ../mykernel_for_linux3.9.4sc.patch
make allnoconfig
make
qemu -kernel arch/x86/boot/bzImage
结果：

五、总结

进程切换是当今多任务多用户操作系统所应具有的基本功能。操作系统为了控制进程的执行，必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程的执行，这种行为被称为进程切换，任务切换或上下文切换。