2018-2019-1 20189215《Linux内核原理与分析》第三周作业

《庖丁解牛》第二章书本知识总结

函数调用框架

call指令有两个作用：

(1) 将CS:EIP中下一条指令的地址A保存在栈顶；

(2)设置CS:EIP指向被调用程序的第一行。

ret指令在被调用函数完成之后，将地址A恢复到CS:EIP中。
传递参数

因为存储参数使用堆栈，根据后入先出的规则，传递参数的方法是从右到左依次压栈。
计算机的3大法宝：存储程序计算机、函数调用堆栈机制、中断。
内嵌汇编语法规则

asm volatile （

汇编语句：

输出部分： //需要在行首加上冒号:

输入部分： //需要在行首加上冒号:

破环描述部分

）

(1)volatile是告诉编译器不要优化代码

(2)汇编代码嵌入时和直接方式有些许不同，体现在%转义符号。寄存器前面会有两个%，而%加数字则表示在输出部分、输入部分、破环描述部分的编号，从零开始，最高到总个数-1。

(3)一些符号

"c"、"d"等符号分别表示寄存器ecx、edx。

"r"表示将输入变量放到通用寄存器，也就是eax、ebx、ecx、edx、esi、edi中的一个。

"="表示操作数在指令中是只写的，输出操作数。

"+"表示输入输出操作数是读写类型的。

"m"表示内存变量。

实验：mykernel时间片轮转多道程序内核

进入实验楼实验，在终端中分别输入以下命令

cd LinuxKernel/linux-3.9.4

rm -rf mykernel

patch -p1 < ../mykernel_for_linux3.9.4sc.patch //打补丁

make allnoconfig

make //编译内核时间较长

qemu -kernel arch/x86/boot/bzImage

make过程如下图：

make成功后mykernel运行：

在mykernel的基础上添加mypcb.h，修改mymain.c和myinterrupt.c文件，实现一个简单的操作系统内核，设置为时钟中断发生100次时，将需要调度的flagmy_need_sched设置为1。运行结果如下:

mykernel时间片轮转代码分析

实验中，基于mykernel，添加了mypcb.h，修改mymain.c和myinterrupt.c文件，下面对这三个文件的代码进行分析。

mypcb.h头文件

#define MAX_TASK_NUM        4

#define KERNEL_STACK_SIZE   1024*8

/* CPU-specific state of this task */

struct Thread {

    unsigned long		ip;   //对应eip

    unsigned long		sp;   //对应esp

};

typedef struct PCB{

    int pid;                 //定义进程id

    volatile long state;	 //-1 unrunnable, 0 runnable, >0 stopped

    char 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，包括：

pid：进程id

state：进程状态，初始化值就是-1，如果被调度运行起来，其值就会变成0 ，被终端后，其值>0

stack：本进程使用的堆栈

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

task_entry：进程入口函数

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

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];  //PCB的数组task

tPCB * my_current_task = NULL; //当前task指针

volatile int my_need_sched = 0; //是否需要调度

void my_process(void);  //my_process函数声明

void __init my_start_kernel(void) //mykernel内核代码的入口

{

    int pid = 0;

    int i;

    /* 初始化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其他进程 */

    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 = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];

        task[i].next = task[i-1].next;

        task[i-1].next = &task[i];

    }

    /* 用task[0]开始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 */

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

        }

    }

}

本实验环境中，mykernel是内核代码的入口，负责初始化内核的各个组成部分，在实际的Linux内核中，入口为init/main.c中的start_kernel(void)函数。

在本实验环境中，每个进程的函数都是 my_process函数，进程在运行中打印当前进程号，并通过my_need_sched变量判断是否需要调度，这是在myinterrupt.c文件中进行赋值的一个变量。

下面对0号进程的启动进行分析：

1"movl %1,%%esp\n\t" %1指第2个输入输出"d" (task[pid].thread.sp)，将进程的栈顶位置存入ESP寄存器

2"pushl %1\n\t" 将task[0].thread.sp压栈，即保存当前EBP值

3"pushl %0\n\t" 将task[0].thread.ip压栈，当前进程的EIP值入栈

4"ret\n\t" 将栈顶值取出到EIP寄存器，即刚刚入栈的0号进程ip值

5 "popl %%ebp\n\t" 在执行完其他进程之后，回到0号进程，释放栈空间

6 : 没有输出

7 : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) 输入，将0号进程的ip、sp值分别存入ecx、edx寄存器中。

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引用全局变量

extern tPCB * my_current_task;

extern volatile int my_need_sched;

volatile int time_count = 0;

void my_timer_handler(void) //时钟中断触发本函数

{

#if 1

    if(time_count%100 == 0 && my_need_sched != 1) //当时钟中断发生100次，并且my_need_sched不为1时，赋值为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);

    	/* 切换进程 */

    	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)

    	); 

    }

    else

    {

        next->state = 0;

        my_current_task = next;

        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);

    	/* switch to new process */

    	asm volatile(

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

}

myinterrupt.c包含my_timer_handler和my_schedule两个函数。 my_timer_handler每隔100次将my_need_sched赋值为1，等待mymain.c中my_process函数的主动调度。my_schedule保存恢复进程上下文。

切换进程的分析：

01 "pushl %%ebp\n\t 保存当前ebp到堆栈中

02 "movl %%esp,%0\n\t" 保存当前ESP到当前进程sp中

03 "movl %2,%%esp\n\t" esp指向下一个进程

04 "movl $1f,%1\n\t" 将1f存储到thread.ip中，$1f是标号“1:\t”处,再次调度到该进程时就会从1:开始执行

05 "pushl %3\n\t" 将下一个进程的ip入栈

06 "ret\n\t" eip指向下一个进程的起始地址，也做了一次出栈操作

07 "1:\t" 标号1:，即next进程开始执行的位置

08 "popl %%ebp\n\t" 待下一个进程执行完后释放栈空间，恢复现场

09 : "=m" (prev->thread.sp),"=m" (prev->thread.ip) %0、%1分别对应，m代表内存变量

10 : "m" (next->thread.sp),"m" (next->thread.ip) %2、%3分别对应

遇到的问题

实验中修改代码后，make找不到文件。

解决：修改代码是在/mykernel目录下进行修改的，make编译内核需要在LinuxKernel/linux-3.9.4目录下进行，修改完之后要cd ..。
不懂myinterrupt.c文件中my_timer_handler函数在哪调用。

解决：仔细看了书上的35页，在实验环境中已经配置好了一个时钟中断，在时钟中断发生的时候就会调用一次该函数。
不懂$1f的含义。

解决：查阅资料得知，"movl $1f,%1\n\t"是将进程原来的ip替换为$1f，是at&t的一种语法，f代表向后跳转（b表示向前，f表示向后），1f指的就是下一条指令，即当前进程的eip。

巴特西

2018-2019-1 20189215《Linux内核原理与分析》第三周作业

《庖丁解牛》第二章书本知识总结

实验：mykernel时间片轮转多道程序内核

mykernel时间片轮转代码分析

遇到的问题

最新文章

热门文章