[linux内核] 1.简单时间片轮转多道程序内核代码分析

学习内容来自庖丁解牛，仅作为个人学习研究用途，如作者认为侵权请联系第一时间删除。

实验中的mykernel

是一个仅支持时钟中断的硬件模拟环境，可以看作一个虚拟的cpu，在此基础上可以写基于时间片轮转的进程调度内核程序。

初始环境理解

初始环境就是实验楼在mykernel目录直接做好的代码，先来分析一下这个简单代码。

cd ~/LinuxKernel/linux-3.9.4/mykernel
rm -rf mykernel
patch -p1 < ../mykernel_for_linux3.9.4sc.patch 会生成mykernel文件下的一些源文件

打patch的过程应该是会设置my_start_kernel当作内核入口函数执行

在此目录下稍微修改一下mymain.c和myintrupt.c两个文件.

然后回到kernel主目录，进行编译

cd ~/LinuxKernel/linux-3.9.4
make allnoconfig
make

注意make后生成新的内核镜像bzImage

用qemu启动修改过的内核镜像

qemu -kernel arch/x86/boot/bzImage

运行效果如下

mymain.c 是 mykernel内核代码的入口，负责初始化内核的各个组成部分。
myinterrupt.c主要是增加进程切换的代码。

分析
应该是固定了在mykernel中的代码调用的my_timer_handler和my_start_kernel这两个函数。

内核从mymain.c进入，之后就陷入while死循环，一直执行其中代码。
此外还有一个时间中断的函数，每当时间中断来临，就会执行一次这个函数。

---

时间片轮转多道程序内核代码分析

可以先清空mykernel目录下的所有文件，然后依次写如下三个文件

源码及理解

//mypcb.h


#define MAX_TASK_NUM    4   //任务数量取4
#define KERNEL_STACK_SIZE   1024*4  //每个进程内核栈大小

/* CPU-specific state of this task */
struct Thread {
    unsigned long		ip;
    unsigned long		sp;
};

//稍后会做成循环链表
typedef struct PCB{ 
    int pid;
    unsigned long stack[KERNEL_STACK_SIZE];
    /* CPU-specific state of this task */
    struct Thread thread;
    struct PCB *next;
}tPCB;  

void my_schedule(void); //时间片轮转调度函数

//mymain.c


#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];    //4个进程任务
tPCB * my_current_task = NULL;  //当前正在执行进程任务
volatile int my_need_sched = 0;     //为1时切换进程

void my_process(void);


void __init my_start_kernel(void)
{
    int pid = 0;
    int i;
    //初始化第0个进程任务
    task[pid].pid = pid;
    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];    //做循环链表
    
    //初始化其他3个进程任务
    for(i=1;i<MAX_TASK_NUM;i++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));
        task[i].pid = i;
	    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];
    }

    //执行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 */
    	: 
    	: "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)	/* input c or d mean %ecx/%edx*/
	);
} 


void my_process(void)
{   
    static int i=0;
    while(1)
    {
        i++;
        if(i%100000 == 0)
        {
            printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);
            if(my_need_sched == 1)  //my_need_sched为1时轮转到下一个进程任务
            {
                my_need_sched = 0;
        	    my_schedule();
        	}
        	printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
        }     
    }
}

mymain.c解读

1、这里一共有4个进程任务，每个进程任务都是执行my_process函数。
而my_process函数里会在my_need_sched=1的时候切换到下一个进程任务。
my_need_sched变量在另一个文件中被修改。

2、嵌入的汇编代码执行完后如下图所示

//myinterrupt.c


#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;
extern volatile int my_need_sched;
volatile int time_count = 0;

//被mykernel代码设定为当前执行的进程任务中的时间中断函数
void my_timer_handler(void)
{
#if 1
    if(time_count%1000 == 0 && my_need_sched != 1)  //my_need_sched != 1表示不需要切换到下一个进程任务
    {
        printk(KERN_NOTICE ">>>my_timer_handler here<<<\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;
       
    my_current_task = next; 
    printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);  
    /* switch to next process */
    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)
    ); 

    return;	
}

myinterrupt.c解读
对于其中的嵌入汇编代码部分，pushl %%ebp和movl %%esp,%0就是保存当前ebp和esp，并把这个地址赋给先在正在执行的进程的sp变量中。
movl %2,%%esp用来把让esp从当前进程栈切换到下一个进程栈的位置。
movl $1f,%1把标号1后的代码作为当前进程下一条要执行的指令赋给当前进程的ip变量中，等下一次切换到该进程时就从这个ip处执行。
pushl %3和ret用来恢复切换到下一个进程的ip，即把下一个进程的ip变量中的值赋值给eip寄存器。注意如果这个进程还没有执行过的话，ip变量存的是my_process函数地址；如果这个进程之前执行过的话，那么这个ip变量存的就是上一次被movl $1f,%1后的值。

---

同目录下编写Makefile文件

obj-y = mymain.o myinterrupt.o
mymain.o:
    cc -c mymain.c mypcb.h
myinterrupt.o:
    cc -c myinterrupt.c mypcb.h

编译运行

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

运行效果

---

时间片轮转多道程序内核代码分析总结

总体来说mypcb.h文件定义了进程相关的结构体，

mymain.c文件中从内核入口my_start_kernel函数开始执行(可能是mykernel内核源码设定)，先初始化了4个进程控制块，然后执行第0号进程任务。

而每个进程都是执行my_process函数，在这个函数中会当my_need_sched=1时进行进程切换，调用my_schedule函数。

变量my_need_sched被设置的时机在于my_timer_handler，这个函数可能是mykernel内核源码中设定为当前执行的进程任务中的时间中断函数。

---

补充知识

编译生成32位汇编代码
gcc -S -o main.s main.c -m32

创建软连接
sudo ln -s 源文件 目标文件

patch在具体使用的时候是不用指定原文件的，
因为补丁文件中已经标记了原文件的路径和名称。
patch -p1 < ../mykernel_for_linux3.94sc.patch

make allnoconfig 
除必须的选项外, 其它选项一律不选. (常用于嵌入式系统)

用qemu启动内核
qemu -kernel arch/x86/boot/bzImage
bzImage是内核的镜像文件