linux内核分析 第二周 操作系统是如何工作的

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

一、计算机是如何工作的

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

　　函数调用堆栈是高级语言得以运行的基础

　　中断时多道程序操作系统的基点

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

　　函数调用框架

　　传递参数

　　保存返回地址

　　提供局部变量空间

三、堆栈相关寄存器

　　esp：堆栈指针

　　ebp：基址地址

　　堆栈操作：push：栈顶地址减少4个字节，pop：栈顶地址增加4个字节

其他关键寄存器：-cs·eip：总是指向下一条指令地址

　　顺序执行：总是指向地址连续的下一条指令

　　跳转/分支：call ret

四、gcc-g生成可执行文件

objdump -S得到反汇编代码

五、传递参数机制

第一句和第二句分别是把y和x的值存入堆栈

六、局部变量的存储机制

第三句是在堆栈中预留一部分空间存储局部变量。

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

查看源代码：

每循环100000次打印一句话

每执行一次，就会有一次时钟中断。

八、c代码中嵌入汇编代码的写法

例：

汇编代码第一句中的%是转义字符

第二句中的%1是指val1，这一句就是把%1即val1的值赋给eax

“c”（val1）意思是把val1的值放入ecx寄存器。

九、一个简单的操作系统内核代码

struct Thread { 
unsigned long        ip; //用于保存eip和esp
unsigned long        sp; 
 }; 

typedef struct PCB{ 
int pid; //进程ID
volatile long state; //进程状态
char stack[KERNEL_STACK_SIZE]; //内核堆栈
/* CPU-specific state of this task */ 
struct Thread thread; 
unsigned long    task_entry; //进程入口（一般都是main函数
struct PCB *next; //进程通过链表连接
}tPCB; 

tPCB task[MAX_TASK_NUM]; //声明一个task数组
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;/* -1 不可运行, 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]; //堆栈的栈顶位置
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].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]; 
} 

pid = 0; 
my_current_task = &task[pid]; 
 asm volatile( 
 "movl %1,%%esp\n\t"     /* set task[pid].thread.sp to esp */ //确定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*/ 
 ); 
 }

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) //执行10 000 000次才判断一次是否需要调度
{ 
 my_need_sched = 0; 
 my_schedule(); 
 } 
 printk(KERN_NOTICE "this is process %d +\n",my_current_task->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 */ //$1f就是指标号1:的代码在内存中存储的地址  
 "pushl %3\n\t"  
 "ret\n\t"   /* restore  eip */ //这两句使得下一个进程的ip作为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) 
 );  

总结：

操作系统具有“两把剑”即中断上下文和进程上下文的切换；这样的特性使得操作系统可以具有一定的标准来选择执行和中断程序，调配资源