《Linux内核分析》第二周学习报告
——操作系统是如何工作的
姓名：王玮怡 学号：20135116
第一节 函数调用堆栈
一、三个法宝
二、深入理解函数调用堆栈
三、参数传递与局部变量
1、根据C代码获得反汇编代码
先通过gcc -g生成test.c的可执行文件test，然后使用objdump -S获得test的反汇编文件。
2、函数参数的存储和调用传递方式
（1）参数存储
x+y: move 0xc(%ebp),%eax
add 0x8(%ebp),%eax
%eax用于函数返回
（2）参数传递
z=p2(x,y):pushl 0xfffffff8(%ebp) //将y的值压进栈
pushl 0xfffffff4(%ebp) //将x的值压进栈
call 804839b<p2>
add $0x8,%esp //清除call之前的内容
mov %eax,0xfffffffc(%ebp) //函数的返回值通过eax寄存器传递
printf(“%d=%d+%d\n”,z,x,y) //依次push y、x、z，最后push常量字串
sub $0x18,%esp //新建一个指定大小的堆栈空间来存储局部变量
代码执行大致过程：
（1）main进栈
（2）p1函数进栈
（3）return
（4）p2进栈
（5）返回main函数堆栈
第二节 借助Linux内核部分源代码模拟存储程序计算机工作模型及时钟中断
一、mykernel实验背后涉及的思想
利用mykernel实验模拟计算机硬件平台
中断：多道程序设计，可以多个程序同时运行
当一个中断发生时，由CPU和内核代码共同实现了保存现场和恢复现场（CPU将eip、esp、ebp都压到内核堆栈中去，并将eip指向一个中断处理程序的入口，保存现场，执行中断处理程序）
时钟中断：每过一定时间发生一次中断。
二、利用mykernel实验模拟计算机硬件平台
1、进入实验楼，输入cd LinuxKernel/linux-3.9.4，执行qemu -kernel arch x86/boot/bzImage加载内核，可以看见一直在执行mystartkernel中的代码；
2、进入mykernel查看代码，包括mymain.c和myinterrupt.c；
3、查看mymain.c（vi mymain.c），找到核心部分代码
修改完相关参数后，输入：wq保存退出；
4、查看myinterrupt.c，找到核心部分代码
每次时钟中断都调用一次printk。
第三节 在mykernel基础上构造一个简单的操作系统内核
一、C代码嵌入汇编代码的写法
1、举例：
说明：
（1）movl $0,%%eax\n\t //%%为转义字符，将0赋给eax，即将eax清零
（2）%n对应下面输出输入部分，从第一个输出开始，编号分别为0、1、2……，在上面代码中，“=m”、“c”、“d”对应序号分别为0、1、2。因此%1对应val1，修饰为“c”（ecx寄存器，即用ecx寄存器存储val1的值 ）
addl%1,%%eax\n\t //将val1的值加到eax中，由于eax有初值0，即为将1+0的值放在eax中；
addl%2,%%eax\n\t //用寄存器edx存储val2的值，并将val2的值加到eax寄存器中，即eax中的值为val2+val1
movl%%eax，%0\n\t //%0对应val3（“=m”为内存变量），将eax寄存器中的值也就是val1+val2的值放入内存变量中，则实现了val1+val2=val3
（3）修饰符
2、练习 
分析：
（1）output为只写，temp为只写， input为用任一通用寄存器来存储；
（2）：“eax”）说明这段代码会破坏eax
（3）“movl $0,%%eax;\n\t” //将eax寄存器里的值置为0；
“movl%%eax，%1\n\t” //将eax里的值赋给temp（即temp的值为0）
“movl%2，%%eax；\n\t” //将input的值放在eax寄存器里（即eax寄存器中的值为1）
“movl%%eax,%0;\n\t” //将eax里的值给output（即output的值为1）
二、一个简单的操作系统内核源代码
| /* | |
| * 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; | |
| unsigned long sp; | |
| }; | |
| 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) | |
| { | |
| 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 */ | |
| { | |
| /* switch to next process */ | |
| 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” | |
| #include “mypcb.h” | |
| //内核初始化和0号进程启动 | |
| tPCB task[MAX_TASK_NUM]; //声明一个叫task的数组 | |
| tPCB * my_current_task = NULL; | |
| volatile int my_need_sched = 0; | |
| void my_process(void); | |
| void __init my_start_kernel(void) | |
| { | |
| int pid = 0; | |
| int i; | |
| /* Initialize process 0*/ | |
| task[pid].pid = pid; //初始化0号进程的数据结构 | |
| task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped */ //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]; //将新创建的进程连接到进程链表的尾部 | |
| } | |
| /* start process 0 by task[0] */ | |
| pid = 0; //启动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) //循环1000万次才有一次机会判断是否需要调度 | |
| { | |
| 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); | |
| } | |
| } | |
| } |
| #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; | |
| if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */ | |
| { | |
| /* switch to next process */ | |
| 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 */ | |
| “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 */ | |
| : “=m” (prev->thread.sp),”=m” (prev->thread.ip) | |
| : “m” (next->thread.sp),”m” (next->thread.ip) | |
| ); | |
| } | |
| return; | |
| } |
三、运行这个精简的操作系统内核
实验总结
通过这一周的学习我大致了解到linux操作系统的工作原理。首先，计算机工作有三大法宝，包括存储程序计算机、函数调用堆栈以及中断机制。另外，进程的实质就是堆栈，进程切换也就是堆栈之间的切换，所以操作系统就是通过不同进程的不断切换来完成工作的。操作系统的“两把剑”：中断上下文和进程上下文的切换。其中中断上下文也就是保存现场和恢复现场。这次的学习内容对我来说难度很大，在听课的过程中理解起来也十分困难。但是感觉有了上一周的基础，基本可以做到自己分析简单的汇编代码。
