美文网首页
简单的内核时间片轮转程序方式

简单的内核时间片轮转程序方式

作者: 梅花小筑 | 来源:发表于2016-03-06 10:34 被阅读171次

    Linux 内核分析MOOC课程已进行到第二周,本周中孟老师给出了一个简单的时间片轮转程序的样例.将带代码加入mykernel后,编译,运行结果图1所示

    图1

    为了实现程序间的切换,该系统在内部用了一个数据结构,struct PCB,来表示每个创建出来的程序.
    在系统启动,首先进入my_start_kernel函数,在该函数中,首先创建了pid为0的初始程序,即系统启动完毕后首先运行的程序所对应的数据结构,代码如下:

        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];
    

    此处将初始进程的入口设置为my_process函数.
    接着创建了MAX_TASK_NUM(4)个其他程序,以便在系统中进行切换操作.

        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];
        }
    可以看出,在创建其他程序的时候,只是复制了初始进程对应的结构体变量里的内容,并将几个特殊字段,pid,sp进行了修改,并且将所有程序(除了初始进程)链接成一个循环单向链表.
    
    

    全局变量my_current_task来保存当前指向正在执行的程序所对应的PCB结构体变量的指针.
    在此处将其赋值为0号初始进程.

    my_current_task = &task[pid];
    

    然后进入关键的程序切换代码,加载初始程序的运行环境,并将eip指向my_process函数.

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

    这段汇编首先将初始进程对应的PCB结构体中的thread.sp赋值给esp,同时将该值压入堆栈,作为在切换回该程序后恢复的ebp寄存器(popl %ebp)使用.接着压入ip并立刻返回,达到了跳转到该程序入口的目的.此时初始进程就真正开始运行工作了.

    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_process中,当i增加到10000000后,打印出本程序的pid后,判断my_need_sched值, 并将其清零.my_need_sched由时钟中断处理过程my_timer_handler进行控制,每隔1000次调用后将该变量置1.

    进入my_schedule函数后,首先根据进程链表和my_current_task变量,得到下一个该调度的程序和当前程序所对应的PCB结构体.并进行实际的切换操作.与从my_start_kernel函数启动初始程序类似.
    该函数依据要调度的程序的PCB结构中的state的值,进行选择,如果该值为0,说明该程序之前被调度过.此时的主要调度代码如下:

            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寄存器已存在堆栈中(在上一次被调度时通过pushl %ebp保存的),并且由于movl $1f,%1的影响,使得每次调度已运行过的程序时,第一句都在执行popl %ebp.所以在调度下一程序时,该程序做的第一件事便是执行1:处的popl %%ebp指令得以恢复ebp.
    而若该程序之前没有被调度运行过,则需要在调度前初始化该程序的整个栈桢,初始为空栈,故将esp,ebp寄存器都设置为thread.sp.切换代码如下:

            asm volatile(   
                "pushl %%ebp\n\t"       /* save ebp */
                "movl %%esp,%0\n\t"     /* save esp */
                "movl %2,%%esp\n\t"     /* restore  esp */
                "movl %2,%%ebp\n\t"     /* restore  ebp */
                "movl $1f,%1\n\t"       /* save eip */  
                "pushl %3\n\t" 
                "ret\n\t"               /* restore  eip */
                : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
                : "m" (next->thread.sp),"m" (next->thread.ip)
            );
    

    其他代码与在my_start_kernel启动初始程序时执行的动作类似.

    我对操作系统是如何工作的认识:
    操作系统通过许多数据结构将系统中的调度单位,资源进行表示和管理.通过利用定时中断机制,处理器可以得到打断当前执行的程序的机会,并判断是否需要进行进程调度,如果需要进行调度,可以通过设置标志变量来进行提示或者直接进行调度.在调度前需要先将当前程序的执行环境保存到对应的结构体字段中,并从要调度的程序所对应的结构体中读取响应字段,并通过指令将其恢复到相应的寄存器中.等到一切环境准备工作就绪后,就可以跳转到下一个程序的入口处了.

    相关文章

      网友评论

          本文标题:简单的内核时间片轮转程序方式

          本文链接:https://www.haomeiwen.com/subject/blowkttx.html