《Linux内核分析》 week2作业-时间片轮转

一.基于时间片轮转调度代码的解读

代码结构主要由三个文件组成:

1.mypcb.h

2.myinterrupt.c

3.mymain.c

1.进程控制块(mypcb.h)

/* CPU-specific state of this task */
struct Thread{
   unsigned long ip;  //eip，程序入口地址
   unsigned long sp;  //堆栈esp栈顶地址
};

typedef struct PCB{
   int pid;  //进程pid号
   volatile long state; //进程运行状态,-1 unrunnable,0 runnable,>0 stopped
   char stack[KERNEL_STACK_SIZE]; //进程的栈空间
   /* CPU-specific state of this task */
   struct Thread thread;  //CPU的相关状态
   unsigned long task_entry; //进程运行对应的函数
   struct PCB *next;  //下一个进程块地址
}tPCB;

void my_schedule(void);

这里进程控制块(PCB)是采用链表的形式链接起来的。

2.进程的切换(myinterrupt.c)

extern tPCB task[MAX_TASK_NUM]; //进程控制块数组
extern tPCB *my_current_task;  //当前对应的进程控制块
extern volatile int my_need_sched; //标志字段，来表示是否需要对进程进行调度

//时钟中断，周期性调用这个函数
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_schedule函数)，采用的是内嵌汇编代码

当下一个进程的状态是正在运行时，则

if(next->state==0){// -1 unrunnable,0 runnable,>0 stopped
    /*switch to next process */
    asm volatile(
        "pushl %%ebp\n\t"    //保存当前进程的栈基址指针 ebp
        "movl  %%esp,%0\n\t" //保存当前进程的栈顶指针 esp
        "movl %2,%%esp\n\t"  //回复下一个进程的栈顶指针 esp
        "movl $1f,%1\n\t"    //将当前进程的下一个指令地址保存到thread.ip中
        "pushl %3\n\t"       //将下一个进程的指令执行地址入栈
        "ret\n\t"            //ip出栈，
        "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)
    );
} 

若下一个进程是新的进程，还没有执行过,基本方式与上面差不多，也是基于内嵌汇编方式实现上下文切换。

3.内核代码运行(mymain.c)

 内核从my_start_kernel开始执行，my_start_kernel主要是进行进程控制块的初始化，同时启动0号进程。

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].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];
    }
    /* 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*/
    );
}   

然后0号进程开始执行my_process函数。

4.程序运行的结果

二.实验总结

通过完成这个简单的时间片轮转多道程序的实验，让我更加深刻的理解了进程上下文切换的原理，以及内核启动的初始化过程。