linux系统分析第一次实验报告

学号：413

原创作品转载请注明出处 https://github.com/mengning/linuxkernel/
使用孟宁老师的github帐号中提供的Mykernel资源，在我的机器上进行了一个关于时间片轮转调度程序的实现。

实验环境：

     . VMware Workstation----->安装Ubuntu16.04虚拟机 . 安装Mykernel（基于Linux Kernel 3.9.4)

按照孟宁老师github帐号中提供的Mykenrnel安装步骤，在本机上进行编译安装。

步骤如下：

sudo apt-get install qemu # install 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
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

编译过程中遇到的问题

由于gcc版本较高，在编译的过程中会遇到compiler-gcc5.h文件丢失。

解决办法：

 直接使用compiler-gcc4.h修改名称进行替换之后编译通过。

###下面是安装linux-3.9.4编译成功之后的截图

编译成功之后运行Mykernel当中的例子，运行结果如下：
对应mymain.c和intterupt.c两个文件，前者是用来循环输出my_start_kernel here语句，后者是用来记录被时钟中断时候的输出。

 参考孟宁老师的代码，在mymain.c和myinterupt.c文件中进行相关代码的修改。

在孟宁老师的github主页中下载主要的文件，下面是该项目的链接：
https://github.com/mengning/mykernel
其中使用到的有mymain.c和myinterrupt.ci以及mypcb.h。
在进行相关代码的修改之后，返回至linux-3.9.4目录下，进行重新编译，命令如下：

cd /your_path/linux-3.9.4/
make clean
make allnoconfig
make -j4

编译完成使用qemu -kernel arch/x86/boot/bzImage命令进行测试。

首先展示运行结果：

上图中展示的是从进程3切换到进程0，以及进程0切换至进程1。

对于几个主要文件进行分析：

mymain.c：初始化各个进程并启动0号进程。
myinterrupt.c：时钟中断处理和进程调度算法。
mypcb.h ：进程控制块PCB结构体定义。

对于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;
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_start_kernel 是系统启动后，最先调用的函数，在这个函数里完成了0号进程的初始化以及启动，并创建了进程PCB。在模拟系统里，每个进程的函数（my_process 函数）在执行的时候，会打印出当前进程的 id，从而使得我们能够看到当前正在执行的进程信息。其中的全局标志变量my_need_sched，其值为 1 时，就调用 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;
extern volatile int my_need_sched;
volatile int time_count = 0;/** Called by timer interrupt.* it runs in the name of current running process,* so it use kernel stack of current running process*/
void my_timer_handler(void)
{
#if 1if(time_count%1000 == 0 && my_need_sched != 1){printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");my_need_sched = 1;} time_count ++ ;
#endifreturn;
}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 */"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;
}

my_timer_handler 函数会被内核周期性的调用，每调用1000次，就将全局变量my_need_sched置1，写入my_schedule中，在my_schedule函数中，完成进程的切换。可以通过下一个进程的state知道该进程是否被调度。进程切换依然是通过内联汇编代码实现，无非是保存旧进程的eip和堆栈，将新进程的eip和堆栈的值存入对应的寄存器中。

最后是mypcb.h

/**  linux/mykernel/mypcb.h**  Kernel internal PCB types**  Copyright (C) 2013  Mengning**/# define MAX_TASK_NUM        4
# define KERNEL_STACK_SIZE   1024*2  /* CPU-specific state of this task */
struct Thread {unsigned long        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;
}tPCB;void my_schedule(void);

该文件内定了PCB的结构体，用于存储当前进程中正在执行的线程的ip和sp的值
PCB结构体中的各个字段含义如下
pid：进程号

state：进程状态，在模拟系统中，所有进程控制块信息都会被创建出来，其初始化值就是-1，如果被调度运行起来，其值就会变成0

stack：进程使用的堆栈

thread：当前正在执行的线程信息

task_entry：进程入口函数

next：指向下一个PCB，mykernel中所有的PCB是以链表的形式组织起来的。

对于函数my_schedule，在my_interrupt.c文件叙述中已叙述过，在mymain.c中的各个进程函数会根据一个全局变量的状态来决定是否调用它，从而实现主动调度。

总结：

 通过该实验，了解了进程调度和中断机制，我们知道当分配个进程的时间用完后需要进程切换时,需要保存当前的执行上下文环境,在进程再次被调度时，以便返回该进程的上下文环境。再次感谢孟宁老师提供的资源。