Linux系统内核分析（基于mykernel完成多进程的简单内核）

最新推荐文章于 2021-05-09 15:23:00 发布

kyhquite

最新推荐文章于 2021-05-09 15:23:00 发布

阅读量242

点赞数

本文链接：https://blog.csdn.net/kyhquite/article/details/88428278

版权

学号后三位163

原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/ ”

一、基于QEMU虚拟处理器编译linux内核

二、时间片轮转调度分析

三、总结

本文主要介绍基于简单的mykernel模拟环境下编译Linux3.9.4内核及编译一个简单的时间片轮转调度的小型内核，帮助分析Linux系统内核的运作过程，mykernel是一个虚拟、可编程的计算机硬件模拟器，可以运行简单的内核调度程序，具体的细节可以参考网址https://github.com/mengning/mykernel，下面我们将介绍如何在虚拟器qemu上编译Linux-3.9.4内核，及基于mykernel平台展示内核运行情况。

一、基于QEMU虚拟处理器编译linux内核

我们先介绍一下虚拟处理器qemu，qemu是一套由法布里斯所编写的以GPL许可证分发源码的模拟处理器，在GNU/Linux平台上使用的广泛。Bochs、PearPC等与其类似，但不具备其许多特性，如高速度与跨平台的特性，通过KQEMU这个闭源的加速器，QEMU能够模拟至接近真实电脑的速度。目前，0.9.1及之前版本的qemu可以使用kqemu加速器。在qemu1.0之后的版本，都无法使用kqemu，主要利用qemu-kvm加速模块，并且加速效果以及稳定性明显好于kqemu。

QEMU主要有两种主要运作模式：

User Mode，即用户模式，QEMU能启动那些为不同中央处理器编译的Linux程序。而Wine及Dosemu是其主要目标。
System mode，系统模式，QEMU能够模拟整个电脑系统，包括中央处理器及周边设备。它使得为跨平台编写的程序进行测试及纠错工作变得容易，亦能用来在一部主机上虚拟多台电脑。

总的来说QEMU就是一台虚拟电脑，我们可以在其上编译内核、运行操作系统、跑程序等各种可在PC机上执行的各种操作。下面我们介绍配置QEMU及编译内核的步骤。

首先需要配置环境，依次输入以下指令：

sudo apt-get install qemu                          //下载qemu
sudo ln -s /usr/bin/qemu-system-i386 /usr/bin/qemu //创建执行文件 
wget https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.9.4.tar.xz # download Linux Kernel 3.9.4 source code                           //下载Linux内核
wget https://raw.github.com/mengning/mykernel/master/mykernel_for_linux3.9.4sc.patch # download 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
make                                               //编译内核
qemu -kernel arch/x86/boot/bzImage                 //执行qemu虚拟器，观察执行环境

执行情况：

执行指令:patch -p1 < ../mykernel_for_linux3.9.4sc.patch

执行指令：make allnoconfig

make

这里需要强调一下，若是在ubuntu环境下的gcc版本高于4.9，尤其是使用16.04版本的Ubuntu，gcc版本变为6.2，编译比较老的项目无法通过，在本实验的情况实在在执行make 指令后会出现缺失compiler-gcc5.h文件，这是由于在linux-3.9.4/inlcude/linux路径下不含有该文件，因此其中一个方法是在网上下载一个compiler-gcc5.h文件，添加到linux-3.9.4/inlcude/linux路径下即可运行，但由于网上该文件资源较少，而且多是收费的（需要积分），我们采取另一种方法解决，降低gcc版本，可以将gcc版本降到Ubuntu14.04时候的4.8版本。

按照下面步骤执行指令：

linux-3.9.4/inlcude/linux  //在Ubuntu16.04上安装低版本gcc比较方便，直接用apt-get下载即可
gcc --version              //安装结束，查看版本信息
ls /usr/bin/gcc*           //查看gcc4.8是否安装成功
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 100
                           //设置gcc默认版本，最后的数字为优先级（值越大越高），由于只有4.8一个 
                           //alternative，不需要纠结数值
sudo update-alternatives --config gcc//查看设置结果（非必须）
gcc --version              //查看gcc版本信息

以上指令也可用于g++版本的更改，若是要恢复原先的版本，执行指令：

 sudo rm /usr/bin/gcc

 ls /usr/bin/gcc*                           //查看原先gcc版本信息

 ln -s /usr/bin/gcc-5 /usr/bin/gcc          //修改gcc默认版本

 gcc --version                              //查看版本信息

执行指令： qemu -kernel arch/x86/boot/bzImage ，从qemu窗口可以看到my_start_kernel在执行，同时my_timer_handler时钟中断处理程序周期性执行，这两句输出出自文件mymain.c+myinterrupt.c。

/* mymain.c*/
void __init my_start_kernel(void){
    int i = 0;
    while(1){
        i++;
        if(i%100000 == 0)
            printk(KERN_NOTICE "my_start_kernel here %d \n",i);
    }
}

/* myinterrupt.c*/
/*
 * Called by timer interrupt.
 */
void my_timer_handler(void)
{
     printk(KERN_NOTICE "\n>>>>>>>>>>>>>>>>>>>>>>>>my_timer_handler here <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\n");
}

根据执行情况可以很清楚的发现内核启动会从 my_start_kernel()开始执行，并周期的发生时钟中断，调用函数my_timer_handller()。

二、时间片轮转调度分析

本小节主要基于一个简单的时间片轮转调度程序来对Linux系统内核的执行情况进行分析，具体的程序代码参考https://github.com/mengning/mykernel下的mymain.c+muinterrupt.c+mypcb.h三个文件，可以下载下来覆盖原先的mymain.c+myinterrupt.c文件，覆盖完成后，依次执行下面的程序，重新编译内核。

cd linux-3.9.4
make allnoconfig
make
qemu -kernel arch/x86/boot/bzImage

下面我们讲解一下这三个文件内的程序执行情况，首先从mypcb.h文件开始，该文件主要声明PCB的结构及线程结构。

#define MAX_TASK_NUM        4                       //定义最大任务数目
#define KERNEL_STACK_SIZE   1024*2 # unsigned long  //定义内堆栈
/* CPU-specific state of this task */
struct Thread {                                     //定义内核线程结构体
    unsigned long		ip;                         //IP指针
    unsigned long		sp;                         //堆栈指针
};

typedef struct PCB{                                 //任务控制块结构体声明
    int pid;                                        //进程号，进程的标识符
    volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
    unsigned long stack[KERNEL_STACK_SIZE];         //堆栈空间
    /* CPU-specific state of this task */    
    struct Thread thread;                           //线程
    unsigned long	task_entry;                     //进程入口
    struct PCB *next;                               //指向下一个pcb
}tPCB;

void my_schedule(void);                             //调度函数

mymian.c文件主要用于初始化内核，首先创建0号进程，然后再创建多个子进程，子进程的数据均与0号进程相同，采用的memcpy(）函数拷贝0进程内容，因此每个进程均执行相同的程序---my_process()。

#include "mypcb.h"

tPCB task[MAX_TASK_NUM];
tPCB * my_current_task = NULL;                     //记录当前执行的进程
volatile int 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 = (unsigned long)my_process;
                                                   //赋值需要执行的操作
    task[pid].thread.sp = (unsigned long)&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].stack[KERNEL_STACK_SIZE-1] - 1) = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-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];
	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*/
	);
} 

int i = 0;

void my_process(void)
{    
    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_interrupt.h文件主要内容是执行任务调度程序，通过进行上下文的切换，实现不同进程之间的切换，通过汇编程序实现现场保护（保存当前任务的堆栈指针）->修改任务IP->修改堆栈指针，执行下一个任务。时间处理函数在每次发生时钟中断时启动，进行计数，当time_count==1000时，my_need_sched =1，即允许进行调度。

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

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 */
    {        
    	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 将next->thread.sp赋值给堆栈指针*/
        	"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)//%0,%1
        	: "m" (next->thread.sp),"m" (next->thread.ip)  //%2,%3
    	); 
    }  
    return;	
}

整个程序的执行过程可以通过以下流程图进行解释，当my_timer_handler()函数中的计数timer_count=1000时，my_need_sched=1,允许进行调度。

三、总结

计算机的基本功能包括三个部分：存储程序计算机（冯诺依曼体系结构）、函数调用堆栈、中断。操作系统通过中断机制，当有中断事件发生时，会触发中断机制，保存当前进程上下文，进行中断处理函数，切换下一个任务的堆栈指针，开始执行下一个任务，放任无执行结束后，恢复上一任务的堆栈，继续执行，从而实现多个任务的切换。