基于mykernel的时间片轮转调度的实现

王智生---原创作品转载请注明出处 

本系列为《Linux内核分析》MOOC课程（http://mooc.study.163.com/course/USTC-1000029000 ）对应学习笔记，文章不定期更新

基于mykernel的时间片轮转调度的实现

本次实验是在linux-3.9.4内核源码库基础上编写程序实现简单的时间片轮转调度功能，也就是每隔一段时间（时间片）切换一次进程。

一、系统环境搭建

资料下载地址：https://github.com/mengning/mykernel

系统环境：ubuntu-kylin14.10_64位

• sudo apt-get install qemu-system        //安装QEMU
• sudo ln -s  /usr/bin/qemu-system-i386  /usr/bin/qemu

//soft link，以后执行qemu命令就等效于执行qemu-system-i386（模拟32位的x86平台）

• wget https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.9.4.tar.xz          //下载linux-3.9.4内核源码
• wget https://raw.github.com/mengning/mykernel/master/mykernel_for_linux3.9.4sc.patch    //下载本课程所需补丁
• xz -d linux-3.9.4.tar.xz
• tar -xvf linux-3.9.4.tar   //解压
• cd linux-3.9.4
• patch -p1 < ../mykernel_for_linux3.9.4sc.patch
• make allnoconfig

二、GNC内联汇编

（空白，后期补上）

三、代码分析

实验主要有三个文件，分别是：mypcb.h、mymain.c、myinterrupt.c，下面依次做下简要介绍：

mypcb.h

/*

 * linux/mykernel/mypcb.h

 * Kernel internal PCB types

 * Copyright (C) 2013  Mengning

 */

#define MAX_TASK_NUM        4

#define KERNEL_STACK_SIZE   1024*8

/* CPU-specific state of this task */

struct Thread {

    unsignedlong        ip;

    unsignedlong        sp;

};

typedefstruct PCB{

    int pid;    //进程ID

    volatilelong state;/* -1unrunnable, 0 runnable, >0 stopped */

    char stack[KERNEL_STACK_SIZE];

    /* CPU-specific state of this task */

    struct Thread thread;

    unsignedlong    task_entry;   //程序入口

    struct PCB *next;   //链表指针

}tPCB;

void my_schedule(void);

 

mypcb.h中主要定义了本次实验最大进程数、内核堆栈大小，两个结构体Thread和PCB，前者存放进程的ip、sp，后者实现类似进程描述符保存进程的关键信息，最后还声明了进程调度程序my_schedule。

*thread在操作系统中准确来说应该为线程，linux下进程和线程是相似的，不同于其他操作系统，这里就不用区分了

mymain.c

/*

 * linux/mykernel/mymain.c

 * Kernel internal my_start_kernel

 * Copyright (C) 2013  Mengning

 */

#include<linux/types.h>

#include<linux/string.h>

#include<linux/ctype.h>

#include<linux/tty.h>

#include<linux/vmalloc.h>

 

#include"mypcb.h"

tPCB task[MAX_TASK_NUM];

tPCB * my_current_task = NULL;

volatileint my_need_sched = 0;

 

void my_process(void);

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 = (unsignedlong)my_process;

    task[pid].thread.sp = (unsignedlong)&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 = (unsignedlong)&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 toeip */

    "popl%%ebp\n\t"

    :

    :"c" (task[pid].thread.ip),"d" (task[pid].thread.sp)  /* input c or d mean %ecx/%edx*/

    );

}  

void my_process(void)

{

    int i = 0;

    while(1)

    {

        i++;

        if(i%1000000000 == 0)

        {

            printk(KERN_NOTICE "this isprocess %d -\n",my_current_task->pid);

            if(my_need_sched == 1)

            {

                my_need_sched = 0;

            my_schedule();

        }

        else   my_schedule();

        printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);

        }    

    }

}

主要声明两个函数：

my_start_kernel:主要实现进程的创建，本次实验中首先声明并运行0号进程，之后依次创建其余进程（处于就绪状态没有运行）；

my_process:进程的内容，在程序中调用my_schedule实现进程轮转调度；

myinterrupt.c

/*

 * linux/mykernel/myinterrupt.c

 * Kernel internal my_timer_handler

 * Copyright (C) 2013  Mengning

 */

#include<linux/types.h>

#include<linux/string.h>

#include<linux/ctype.h>

#include<linux/tty.h>

#include<linux/vmalloc.h>

 

#include"mypcb.h"

 

extern tPCB task[MAX_TASK_NUM];

extern tPCB * my_current_task;

externvolatileint my_need_sched;

volatileint time_count = 0;

/*

 * Called by timer interrupt.

 * it runs in the name of currentrunning process,

 * so it use kernel stack of currentrunning process

 */

void my_timer_handler(void)

{

#if 1

    if(time_count%1000 == 0 &&my_need_sched != 1)

    {

        printk(KERN_NOTICE ">>>my_timer_handlerhere<<<\n");

        my_need_sched = 1;

    }

    time_count ++ ; 

#endif

    return;    

}

 

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---->进程上下文切换*/

    asmvolatile(  

        "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 */  

        //$1f--->means the location of标号 1：

        "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)

    );

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

    asmvolatile(  

        "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)

    );         

    }  

    return; 

}

同样声明了两个函数：

my_timer_handler:中断处理程序，其时钟中断机制由qemu硬件模拟器内部实现，该中断处理程序周期执行，独立于其他程序。

my_schedule：进程轮转调度的实现函数，后面会详细介绍

 

l  程序执行过程：

程序由my_start_kernel开始执行，依次初始化所有进程，注意每个进程都有自己独立的堆栈，之后启动0号进程，配置相关环境。实现代码为：

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 toeip */

    "popl%%ebp\n\t"

    :

    :"c" (task[pid].thread.ip),"d" (task[pid].thread.sp)  /* input c or d mean %ecx/%edx*/

    );

该段汇编将进程堆栈的SP、BP值赋给模拟x86硬件平台的SP、BP，加之前面

 task[pid].task_entry =task[pid].thread.ip = (unsignedlong)my_process;

声明了进程入口地址即为my_process函数入口地址（不同进程均对应my_process函数，这里就用process_0表示）；此时process_0启动，每隔一段时间判断进程是否需要轮换(my_need_sched=1?)，中断处理程序则是在一定时间后发出轮换的命令（即令my_need_sche为1），之后便进入my_schedule实现进程轮换，依此循环。

轮换实现机制：

两个指针prev和next分别指向当前进程和待轮换的下一进程，之后用一段内联汇编：

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

        //$1f--->means the location of标号 1：

        "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)

    );

前两句将当前process的ebp入栈，esp存入prev->thread.sp中，将新process的next->thread.sp存入esp，之后执行：

    "movl $1f,%1\n\t"      /* saveeip */  

把标号“1”对应的地址存入prev->thread.ip，1f中f应为”forward”即向前寻找标号为“1”的地址，即下面的：

    "1:\t"                  /* next process start here */

所以下次重新轮到当前process时，程序从eip所对应的地址即该处开始执行，下面一句为：

    "popl %%ebp\n\t"

把最开始压入栈的ebp弹出，下次process_0就可以从当前执行位置继续执行，实现了保护现场和恢复现场的作用。

中间的一段：

        "pushl%3\n\t"

        "ret\n\t"               /* restore  eip */

则是将下一process的eip地址赋给当前eip；总个汇编执行完就实现了进程的轮换调度！

系统搭建好之后，在终端下依次输入：

• make
• qemu -kernel arch/x86/boot/bzImage

qemu窗口中可以看到相应的提示！！！

（注意！这里我QEMU自身问题导致中断处理程序没法运行。。。。暂时还在调试中）

 

总结：

这只是一个简单的例子来说明进程时间片轮换调度的实现，具体到操作系统的工作原理，操作系统在bootloader启动的后面会启动一个init的进程，为所有其他进程的父进程，由该父进程陆续启动n多的子进程，进行进程的管理和调度。