20135220谈愈敏Blog2_操作系统是如何工作的

操作系统是如何工作的

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

计算机是如何工作的？（总结）——三个法宝

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

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

  enter
  
  pushl %ebp
  
  movl %esp,%ebp

  leave
  
  movl %ebp,%esp
  
  popl %ebp

  函数参数传递机制和局部变量存储

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

函数调用堆栈

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

• 函数调用框架
• 传递参数
• 保存返回地址
• 提供局部变量空间

堆栈相关寄存器：esp堆栈指针ebp基址指针,记录当前函数调用基址

堆栈操作：push,pop

cs:eip：总是指向下一条的指令地址，执行call的时候，保存下一条指令地址到栈顶，然后cs:eip指向调用函数入口地址。

建立被调用者函数的堆栈框架：

pushl %ebp
movl %esp,%ebp

解除被调用者函数的堆栈框架：

movl %ebp,%esp
popl %ebp
ret

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

由CPU和内核代码共同实现了保存现场和恢复现场

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

内嵌汇编语法

__asm__(                 这里是两个短的下划线
	汇编语句模版：
	输出部分：
	输入部分：
	破坏描述部分）；

实验部分

实验过程及截图：

实验代码分析：

mypcb.h：头文件

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

#define MAX_TASK_NUM4
#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 */ //进程状态，-1等待，0运行，>0停止
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);      //调度器

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];        //声明一个task数组,tPCB结构体类型在mypcb.h中有定义
tPCB * my_current_task = NULL;  //表示当前task指针
volatile int my_need_sched = 0; //表示是否需要调度

void my_process(void); 

void __init my_start_kernel(void)
{
	int pid = 0;               //初始进程号，修改方便
	int i;
	/* Initialize process 0*/  //0号进程的初始化过程
	task[pid].pid = pid;
	task[pid].state = 0;       //0表示可运行
	task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process; //入口是my_process
	task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1]; //堆栈的栈顶位置
	task[pid].next = &task[pid]; //下一个进程next还是指向自己（刚启动时没有其他进程）

	/*fork more process */    //创建更多进程
	for(i=1;i<MAX_TASK_NUM;i++)
	{
		memcpy(&task[i],&task[0],sizeof(tPCB)); //复制0号进程的状态
		task[i].pid = i;      //创建的新进程号
		task[i].state = -1;   //-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] */ //执行0号进程
	pid = 0;                 //初始进程号，修改方便
	my_current_task = &task[pid];
	asm volatile(            //嵌入式汇编代码
		"movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp */ //将进程的sp赋给esp寄存器
		"pushl %1\n\t"  /* push ebp */ //当前的栈是空栈，ebp等于esp，所以push的%1是esp也就是ebp
		"pushl %0\n\t"  /* push task[pid].thread.ip */ //ip入栈
		"ret\n\t"   /* pop task[pid].thread.ip to eip */ //ip弹栈赋给eip，0号进程正式启动
		"popl %%ebp\n\t"
		:
		: "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   /* input c or d mean %ecx/%edx*/
 		);
} //内核初始化完成，0号进程开始执行

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) //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)
	{
		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; 

	//两个进程之间的上下文切换
	//情况1：下一个进程为next->state == 0 正在执行
	if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
	{
		/* switch to next process */
		asm volatile(    //嵌入式汇编代码
			"pushl %%ebp\n\t"   /* save ebp */     //保存当前进程的ebp
			"movl %%esp,%0\n\t" /* save esp */     //把当前进程的esp赋值到sp中
			"movl %2,%%esp\n\t" /* restore  esp */ //把下一个进程的sp放到esp中
			"movl $1f,%1\n\t"   /* save eip */     //$1f指标号1:的代码在内存中存储的地址
			"pushl %3\n\t"                         //保存下一个进程的ip作为eip
			"ret\n\t"   /* restore  eip */         //还原eip,执行下一个进程
			"1:\t"  /* next process start here */  //标号1，下一进程从此开始
			"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
	} 

	//情况2：进程是一个从来没有执行过的新进程
	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 */ //将下一进程的sp存入esp
			"movl %2,%%ebp\n\t" /* restore  ebp */ //因为栈空，新进程的esp和ebp都指向相同位置
			"movl $1f,%1\n\t"   /* save eip */
			"pushl %3\n\t"                         //保存当前进程的入口
			"ret\n\t"   /* restore  eip */         //还原eip
			: "=m" (prev->thread.sp),"=m" (prev->thread.ip)
			: "m" (next->thread.sp),"m" (next->thread.ip)
			);
	}
	return;
}

总结

本节讲的是操作系统是如何工作的，首先总结了一下计算机是如何工作的，计算机有三大法宝：存储程序计算机工作模型、函数调用堆栈和中断机制，而操作系统也是有两把利剑：中断上下文和进程上下文的切换，重点是搞懂进程如何启动，还有进程切换的两种情况：情况1：下一个进程为next->state == 0 正在执行，情况2：进程是一个从来没有执行过的新进程。操作系统是建立在硬件基础上的，却不纠结于硬件上的细节，有自己对资源的调度管理，也有自己的一套规则。