Linux内核分析-完成一个简单的时间片轮转多道程序内核代码

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

1、实验图

这次试验的内核由Linux3.9.4修改而来，详情见https://github.com/mengning/mykernel

2、代码分析

mypcb.h

#define MAX_TASK_NUM        4                   //最大的任务数
#define KERNEL_STACK_SIZE   1024*8              //每个进程堆栈的大小

/* CPU-specific state of this task */
struct Thread {
    unsigned long       ip;                //对应于eip
    unsigned long       sp;                 //对应于esp
};

typedef struct PCB{
    int pid;                     //进程id
    volatile long state;    /*进程状态 -1 unrunnable, 0 runnable, >0 stopped */
    char stack[KERNEL_STACK_SIZE];  //堆栈空间
    /* CPU-specific state of this task */ 
    struct Thread thread;   //线程结构体
    unsigned long   task_entry;   //入口地址
    struct PCB *next;  //下一个进程
}tPCB;

入口函数

extern tPCB task[MAX_TASK_NUM];                        //进程空间  
extern tPCB * my_current_task;                         //当前进程  
extern volatile int my_need_sched;                     //  
volatile int time_count = 0;  
void __init my_start_kernel(void)  
{  
    int pid = 0;  // 初始进程id 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;//进程的入口和进程的eip都为my_process  
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];//进程的esp大小为KERNEL_STACK_SIZE，初始化esp指向它的末尾  
    task[pid].next = &task[pid]; //初始化进程的下个进程为自己  
/*fork more process ，fork更多的进程 */   
    for(i=1;i<MAX_TASK_NUM;i++) {  
          memcpy(&task[i],&task[0],sizeof(tPCB)); //进程状态简单复制   
          task[i].pid = i; //进程pid  
          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]; //汇编运行0号进程  
      asm volatile(  
                "movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp 使用进程的堆地址，即esp指向进程的堆空间*/   
                "pushl %1\n\t" /* push ebp 这里为什么是push ebp不懂了，理论上是压入了esp的地址（老师解释这里是由于栈是空的ebp等于esp）*/   
                "pushl %0\n\t" /* push task[pid].thread.ip，压入eip地址，等待运行 */   
               "ret\n\t" /* pop task[pid].thread.ip to eip，回顾上一周的课程可知，这里是把eip的地址指向了task[pid].thread.ip的地址了,并popl了一次*/   
                "popl %%ebp\n\t" /*弹出ebp，整个进程空间释放了*/     
                 :  
         : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) /* input c or d mean %ecx/%edx*/);  
     }   
//下面是进程工作的代码，代码很简单就是 每10000000 来运行一次，相隔着来进行进程的调度切换，至于是否调度切换是有标志my_need_sched 来决定的。  
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_schedule（）

<pre name="code" class="cpp">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 */  
    {  
        /* switch to next process */  
        asm volatile(     
            "pushl %%ebp\n\t"       /* save ebp ，保存当前进程的ebp，保存现场 */  
            "movl %%esp,%0\n\t"     /* save esp ，保存当前进程的esp到 prev->thread.sp*/  
            "movl %2,%%esp\n\t"     /* restore  esp，读取下个进程的esp */  
            "movl $1f,%1\n\t"       /* save eip ，保存eip，即存储1 编号出的指针运行地址到prev->thread.eip中 
*/    
            "pushl %3\n\t"           /*压入下个进程的ip，注意如果进程运行过的话，这里的thread.ip指向的是标号1:的位置*/  
            "ret\n\t"               /* restore  eip ,运行下个进程，并popl掉%3 */  
            "1:\t"                  /* next process start here ，上个进程（ret的进程运行完了），恢复为原来进程*/  
            "popl %%ebp\n\t"        /*弹出ebp，恢复现场*/  
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)  
            : "m" (next->thread.sp),"m" (next->thread.ip)  
        );   
        my_current_task = next;   
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);        
    }  
    else  
    {  
//下个进程还没运行，则切换到新的进程  
        next->state = 0;   //改变下个进程的状态  
        my_current_task = next;  //当前进程指向下个进程  
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);  
        /* switch to new process */  
        asm volatile(     
            "pushl %%ebp\n\t"       /* save ebp，保存当前进程的ebp */  
            "movl %%esp,%0\n\t"     /* save esp，保存当前进程的esp到 prev->thread.sp*/  
            "movl %2,%%esp\n\t"     /* restore  esp，读取下个进程的esp */  
            "movl %2,%%ebp\n\t"     /* restore  ebp ，赋值ebp，使得esp=ebp*/  
            "movl $1f,%1\n\t"       /* save eip ，保存eip，即存储1编号出的指针运行地址到prev->thread.eip中*/      
            "pushl %3\n\t"           /*压入下个进程的ip*/  
            "ret\n\t"               /* restore  eip，运行下个进程 */  
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)  
            : "m" (next->thread.sp),"m" (next->thread.ip)  
        );            
    }     
    return;   
}  

定时中断函数

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;       
}  
//定时器中断，每1000下进行my_need_sched的检查，如果不为1，则置其为1使其进程调度

总结

从上文的简单的内核进程切换代码，可以看出系统运行，在各个进程间如何通过ebp和esp的改变和保存，来进行上下文切换的。另外系统通过时间中断来使得各个进程获得了切换的机会，这是个时分复用的内核机制。在真正的系统，中断有很多种，例如时钟，各种硬件IO等，内核接收到这些中断后，进行对应的进程切换，使得系统进程可以进行各种对应的处理操作。