linux 基于时间片轮转的进程切换
学号：413 原创作品 转载注明出处
课程：《Linux操作系统分析》 https://github.com/mengning/linuxkernel/
内容:主要讲述Linux操作系统中时间片轮转调度方法中，进程切换的实现方法和切换过程的堆栈的变化
一、环境
该博客内容来自与课堂作业， mykernel，这是一个完成多进程的简单内核，该内核基于Linux Kernel 3.9.4 ，虚拟机是实验楼http://www.shiyanlou.com/courses/195提供的虚拟机，按照其实验步骤操作
在虚拟机中打开shell
执行以下命令
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运行结果如下图所示，我们可以看到qemu窗口运行起来了：
cd mykernel,打开 mymain.c代码，和myinterrupt.c代码
从代码中可以看到该程序只是不停的打印my_start_kernel here和my_timer_handler here。
二、实现时间片轮转调度及代码分析
我们需要在上诉的基础上，修改代码，来实现时间片轮转调度，代码可从mykernel找到，将其中的mypcb.h,myinterrupt.c和mymain.c三个文件替换实验楼中，将myinterrupt.c和mymain.c替换掉，而mypcb.h是新增文件
完成后执行下列代码
make allnoconfig
make
qemu -kernel arch/x86/boot/bzImage运行结果如下图所示
下面我们来对代码进行分析
在mypcb.h中定义了调度进程的pcb的数据结构，和thread结构，PCB中记录了操作系统所需的，用于描述进程的当前情况以及控制进程运行的全部信息。
struct Thread {
unsigned long ip;//当前程序执行的指令
unsigned long sp;//程序的堆栈的栈顶位置
};typedef struct PCB{
int pid;//进程id
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;myinterrupt.c中
对进程pcb进行初始化，并将其链成循环链表
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].state = -1;
task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];
task[i].next = task[i-1].next;
task[i-1].next = &task[i];
}
下面插入的汇编代码，实现了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 */
:
: "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) /* input c or d mean %ecx/%edx*/
);先将 task[0]赋为当前正在执行的进程，将当前进程的sp赋值给esp，将当前进程的sp压栈，将当前进程ip压栈，ret指令执行将栈顶的ip出栈并跳转。
my_need_sched变量，表示进程是否要切换，若是1，则要切换，0表示不需要切换，myinterrupt.c中的my_timer_handler函数，计算时间片，若时间片达到1000个时钟，则将my_need_sched赋值为1.
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;
}myinterrupt.c中的my_schedule函数实现切换
next = my_current_task->next;
prev = my_current_task;这两条代码将指针指向下一个进程的pcb，之后还需要对前一个进程的上下文环境进行保存
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)
); 这也是嵌入的一段汇编代码，先将前一个进程的ebp压栈，然后将esp寄存器保存到的栈顶指针保存到对应进程的pcb中，将下一个要执行的进程的sp从pcb中取出放入到esp中，"movl $1f,%1\n\t"表示将下一个最近的标签为1 的地址当做ip存入上一个进程的pcb的ip中，则当该程序再次执行时是从标签为1 的位置开始执行，将下一个进程的ip压栈。此时已经完成了进程的切换。
mymain.c中的my_process表示进程的执行
void my_process(void)
{
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);
}
}
}该函数一直判断i是否到达10000000个单位，若没有则一直打印当前执行进程的id，否则判断my_need_sched是否为1，若是，则将其值修改为0，调用my_schedule函数进行切换。
三、总结
通过本讲的学习和实验，我们知道操作系统的核心功能就是：进程调度和中断机制，通过与硬件的配合实现多任务处理，再加上上层应用软件的支持，最终变成可以使用户可以很容易操作的计算机系统。