20135323符运锦----第二周：操作系统是如何工作的

函数调用堆栈

一、三个法宝：

①存储程序计算机工作模型，计算机系统最最基础性的逻辑结构

②函数调用堆栈，高级语言得以运行的基础，只有机器语言和汇编语言的时候堆栈机制对于计算机来说并不那么重要，但有了高级语言及函数，堆栈成为了计算机的基础功能；函数参数传递机制和局部变量存储.

	--enter
	pushl %ebp
	movl %esp,%ebp
	--leave  
	movl %ebp,%esp
	popl %ebp`

③中断，多道程序操作系统的基点，没有中断机制程序只能从头一直运行结束才有可能开始运行其他程序。

二、堆栈

1.堆栈是C语言程序运行时必须的一个记录调用路径和参数的空间。

2.堆栈的作用：函数调用框架、传递参数、保存返回地址、提供局部变量空间，等等。

3.堆栈相关的寄存器：esp，堆栈指针（stack pointer）；ebp，基址指针（base pointer）。

4.堆栈操作：push栈顶地址减少4个字节（32位）； pop栈顶地址增加4个字节。注：ebp在C语言中用作记录当前函数调用基址。

5.其他关键寄存器：cs : eip：总是指向下一条的指令地址；顺序执行：总是指向地址连续的下一条指令； 跳转/分支：执行这样的指令的时候，cs : eip的值会根据程序需要被修改。call：将当前cs : eip的值压入栈顶，cs : eip指向被调用函数的入口地址。 ret：从栈顶弹出原来保存在这里的cs : eip的值，放入cs : eip中。

6.

7.补充：

首先使用gcc –g 生成test.c的可执行文件test

然后使用objdump –S获得test的反汇编文件

有压栈必有出栈

函数返回值通过eax寄存器传递

sub $0x18,%esp：提前预留出0x18段字节，用于存储局部变量

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

中断实现了多道程序设计，再各个程序的执行流之间来回切换，CPU将程序的ebp压入栈，并指向一个中断处理程序，从而由CPU和内核代码共同实现了保存现场和恢复现场；当一个中断信号发生的时候，CPU把当前的esp,ebp,eip压入内核堆栈中，然后让eip指向中断处理程序入口去处理中断。

在mykernel基础上构造一个简单的操作系统内核

实验内容

使用实验楼的虚拟机打开shell

cd LinuxKernel/linux-3.9.4

qemu -kernel arch/x86/boot/bzImage

然后cd mykernel 您可以看到qemu窗口输出的内容的代码mymain.c和myinterrupt.c。

在mymain.c的my_start_kernel函数中有一个循环，不停的输出my_start_kernel here

时间中断处理程序，每执行一次，都会执行一次时钟中断，每次时钟中断都调用printf并输出。

代码分析#

mypcb.h

主要用于数据结构的定义

/*
*  linux/mykernel/mypcb.h
*
*  Kernel internal PCB types
*
*  Copyright (C) 2013  Mengning
*
*/

#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;
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);//调用了my_schedule，调度器

mymain.c

内核初始化和0号进程启动

/*
*  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];//声明一个task数组,tPCB结构体类型在mypcb.h中有定义
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;
task[pid].state = 0;/*  -1 不可运行, 0 可运行, >0 停止 */
task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;
//定义进程0的入口为my_process
task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];//堆栈的栈顶位置，这个在mypcb.h中也有定义
task[pid].next = &task[pid];
//下一个进程还是指向自己
/*fork more process */
//创建更多其他的进程，在初始化这些进程的时候可以直接拷贝0号进程的代码
for(i=1;i<MAX_TASK_NUM;i++)
{
    memcpy(&task[i],&task[0],sizeof(tPCB));//copy一下0号进程的状态，然后需要修改的地方再修改
    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] */新的堆栈中的ebp和eip都与task[i]相匹配
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 */当前的栈是空的，ebp就等于esp
    "pushl %0\n\t"          /* push task[pid].thread.ip */IP压栈
    "ret\n\t"               /* pop task[pid].thread.ip to eip */弹出来eip，这之后0号进程正式启动
    "popl %%ebp\n\t"//弹出来ebp,内核初始化工作完成
    : 
    : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   
    /* input c or d mean %ecx/%edx*/
);
}
/*  

	movl %1,%%esp表示把参数thread.sp放到esp中,其中%0表示参数thread.ip，%1表示参数thread.sp。接下来push %1，又因为当前栈为空，esp=ebp，所以等价于push ebp；
   
 */

	void my_process(void)//
{
int i = 0;
while(1)
{
    i++;
    if(i%10000000 == 0)//执行10 000 000次才判断一次是否需要调度
    {
        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);
    }     
}
}

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 1
    if(time_count%1000 == 0 && my_need_sched != 1)//设置时间片的大小，时间片用完时设置一下调度标志。只要满足上述两个条件，就将my_need_sched设为1，这样mymain.c循环到这个进程的时候就可以对这个进程进行调度
    {
        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 //task为空，即发生错误时返回
    || 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)/* -1 unrunnable, 0 runnable, >0 stopped */在两个正在执行的进程之间做上下文切换
    {
        /* switch to next process */
        /*如果下一个进程的状态是正在执行的话，就运用if语句中的代码表示的方法来切换进程*/
        asm volatile(   
            "pushl %%ebp\n\t"       /* save ebp 保存当前进程的ebp*/
            "movl %%esp,%0\n\t"     /* save esp 保存当前进程的esp*/
            "movl %2,%%esp\n\t"     /* restore  esp 把下一个进程的sp放到esp中*/
            "movl $1f,%1\n\t"       /* save eip 保存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)
        ); 
        my_current_task = next; 
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);      
    }
    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 */这两句使得下一个进程的ip作为eip，这样下一个进程就会接下来执行
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
            : "m" (next->thread.sp),"m" (next->thread.ip)
        );          
    }   
    return; 
}

最后，实现的效果就是0，1，2，3号进程依次循环切换。

操作系统是如何工作的

操作系统的“两把利剑”：中断上下文、进程上下文的切换。

符运锦 原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000