基于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

#include

#include

#include

#include

 

#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

    {

       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

#include

#include

#include

#include

 

#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:进程轮转调度的实现函数,后面会详细介绍

 

程序执行过程:

程序由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自身问题导致中断处理程序没法运行。。。。暂时还在调试中)

 基于mykernel的时间片轮转调度的实现_第1张图片

总结:

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

你可能感兴趣的:(Linux内核分析,操作系统,linux内核)