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

1.问题描述

计算机的3大法宝是存储程序计算机，函数调用堆栈和中断机制，存储程序计算机已经在上一个博客中进行具体描述，本文将在剩下两方面出发对操作系统是如何工作的进行学习和探讨。

2.解决过程

2.1 计算机的三大法宝概念

存储程序计算机：将程序存放在计算机存储器中，然后按照存储器中的存储程序的首地址执行程序的第一条指令，以后就按照该程序中编写好的指令执行，直至程序执行结束。

函数调用堆栈：C语言程序运行时必须使用的记录函数调用路径和参数存储的空间。

中断：计算机运行过程中，出现某些意外情况需主机干预时，机器能自动停止正在运行的程序并转入处理新情况的程序，处理完毕后又返回原被暂停的程序继续运行。

2.2 函数调用堆栈工作原理

堆栈调用中有两个非常重要的指针，ESP和EBP。

ESP：堆栈栈顶指针，用于指向一个堆栈的最顶层，也就是低地址。

EBP：堆栈基址指针，用于指向当前堆栈的始发地址，也就是高地址。

在C语言编码中，堆栈空间可能未一段连续地址的存储空间，但通过ESP和EBP指针，可以确定一段堆栈空间为函数堆栈。函数调用堆栈就是多个逻辑上的栈堆叠起来的框架，需要注意的是在x86体系结构中，堆栈空间是从高地址向低地址增加的，每个存储单元的地址相差4个字节。

堆栈的主要操作是push和pop，分别用于将操作数放入栈顶和将栈顶存储单元的内容放入操作数两个相反的操作。

以下是图解过程：

2.3 借助Linux内核部分源代码模拟存储程序计算机工作模型及时钟中断

由上一节已经知道了函数调用堆栈的变化，中断机制与之类似，只不过处理者为CPU，处理的堆栈为内核堆栈而非一般堆栈。中断执行前后通过机器硬件会保护中断前现场，然后CPU会根据CS：EIP指向的中断处理程序入口地址执行中断后的程序，执行完后会恢复中断前现场。本节将虚拟一个x86的CPU，用于中断的演示和介绍。研究思路是在实验过程中通过程序模拟时钟中断，每隔一段时间发生一次时钟中断，通过时间轮转片调度操作系统内核。

2.3.1 代码分析

接下来将通过汇编一个简单的C语言程序并分析其汇编指令执行过程,该程序主要包括3个代码文件。

mypcb.h

#define MAX_TASK_NUM        4     #定义最大任务数
#define KERNEL_STACK_SIZE   1024*8   #定义内核堆栈的个数

struct Thread {                                      #定义线程结构体
    unsigned long ip;                                      #对应eip寄存器
    unsigned long sp;                                       #赌赢eso寄存器
};

typedef struct PCB{                                        #定义进程控制块参数
    int pid;                                      #定义进程id
    volatile long state;                                        #定义状态，-1表示未运行，0表示运行，>0表示停止
    char stack[KERNEL_STACK_SIZE];                                       #定义内核堆栈个数
    struct Thread thread;                                       #创建线程
    unsigned long	task_entry;                                       #定义入口地址
    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];
tPCB * my_current_task = NULL;
volatile int my_need_sched = 0;

void my_process(void);

void __init my_start_kernel(void)  #进入内核入口，初始化进程各参数
{
    int pid = 0;                                 #初始化0号进程
    int i;
    /* Initialize process 0*/
    task[pid].pid = pid;                    #设置进程id
    task[pid].state = 0;                     #设置进程状态为0
    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];            #设置ESP指向栈顶
    task[pid].next = &task[pid];                #设置堆栈指针指向当前堆栈

    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];                                 #加入进程列表尾部
    }
    /* start process 0 by task[0] */
    pid = 0;
    my_current_task = &task[pid];
	asm volatile(
    	"movl %1,%%esp\n\t" 	#将task[pid].thread.sp移入ESP
    	"pushl %1\n\t" 	        #将EBP入栈
    	"pushl %0\n\t" 	#将task[pid].thread.ip入栈
    	"ret\n\t"  	#将task[pid].thread.ip返回赋入eip
    	"popl %%ebp\n\t" 	#将ebp压出栈
    	:
    	: "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) 	#设置ecx和edx存储不同参数
	);
}
void my_process(void)
{
    int i = 0;
    while(1)
    {
        i++;
        if(i%10000000 == 0) 	#每计数10000000，会输出this is process 和当前进程任务号
        {
            printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);
            if(my_need_sched == 1)
#判断是否需要切换进程,1需要切换，将状态值赋为0，并执行my_schedule(), 0不需要切换
            {
                my_need_sched = 0;
        	    my_schedule();
        	}
        	printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid); 	#输出this is process 和当前进程任务号
        }
    }
}

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;
#时钟中断程序
void my_timer_handler(void)
{
#if 1
    if(time_count%1000 == 0 && my_need_sched != 1)
#如果时钟计数可以整出1000，且不需要切换进程，打印输出my_timer_handler here,并切换状态
    {
        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;                   #用指针next指向下一个进程
    prev = my_current_task;                   #用指针prev指向当前进程
    if(next->state == 0)                    #判断下一进程曾执行过
    {
    	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" 	    # 将ebp入栈保存
        	"movl %%esp,%0\n\t" 	#保存当前进程ESP到PCB
        	"movl %2,%%esp\n\t"     #将next进程的栈顶地址存入ESP
        	"movl $1f,%1\n\t"       #保存当前EIP寄存器值到PCB
        	"pushl %3\n\t"         #把下一个进程代码入口地址入栈
        	"ret\n\t" 	            #出栈进程的代码入口地址返回到EIP寄存器
        	"1:\t"                  #标号1，即next进程开始执行的位置
        	"popl %%ebp\n\t"         #恢复EBP寄存器的值
        	: "=m" (prev->thread.sp),"=m" (prev->thread.ip)
#将当前和下一个进程栈顶地址和ip地址存入内存寄存器中，并根据变量%0%1%2%3命名
        	: "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" 	    #保存当前进程EBP到堆栈
        	"movl %%esp,%0\n\t" 	#保存当前进程ESP到PCB
        	"movl %2,%%esp\n\t"      #将next进程的栈顶地址保存到ESP寄存器
        	"movl %2,%%ebp\n\t"     #将next进程的堆栈基地址保存到EBP寄存器
        	"movl $1f,%1\n\t"       #将当前EIP寄存器值存到PCB，标号为1
        	"pushl %3\n\t"           #把下一个进程入口地址入栈
        	"ret\n\t" 	            #将出栈进程的代码入口地址存到EIP寄存器
        	: "=m" (prev->thread.sp),"=m" (prev->thread.ip)
        	: "m" (next->thread.sp),"m" (next->thread.ip)
    	);
    }
    return;
}

2.3.2 演示操作

本实验演示将在实验楼环境下运行，运行下段代码

# 注意路径是区分大小的
$ 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

运行结果如下图所示：

3.总结

本文主要研究了函数调用堆栈和中断机制，两者在思想上有一定的相似之处，都需要通过堆栈调用。但是前者主要通过用户空间进行调用，在用户态；后者则通过操作系统内核调用，在内核态。中断更多的用于异常操作，是一种硬件机制，具有不可预料性，一般没有返回值，而函数调用可以发生在任何时刻，可以认为控制，有返回值，能传递参数。在了解了两者的异同点后，又通过具体的堆栈调用图和代码进行分析，对函数调用堆栈和中断机制有了进一步的了解。