上周已经一步步地分析过含有变量的函数调用时堆栈的变化，现在对堆栈框架进行一些补充，以以下程序为例：
int main()
{
...
g(x,y);
...
}
int g(int x,int y)
{
h(c);.
}
int h(int x)
{
...
}
大致栈空间以及自己领会的函数调用堆栈变化框架：
2.时间片轮转多道程序代码分析：计算机工作的三个法宝是存储程序计算机、函数调用堆栈、中断机制。mykernel 启动后，会调用 my_start_kernel 函数，完成进程的初始化，时钟中断周期性地调用 my_timer_handler函数，完成进程的调度。
扩展 my_start_kernel 和 my_timer_handler 函数，即修改 mymain.c 和 myinterrupt.c，新增 mypcb.h，模拟时间片轮转的多道程序，现在将内核核心代码加以分析:
mypcb.hstruct Thread {
unsigned long ip;
unsigned long sp;
};
typedef struct PCB{
int pid; //进程的id号
volatile long state; //进程的状态
char stack[KERNEL_STACK_SIZE]; //进程的栈
struct Thread thread; //Thread 结构体
unsigned long task_entry; //进程的起始入口地址
struct PCB *next; //指向下一个进程的指针
}tPCB;
void my_schedule(void); //此函数执行进程调度
定义了PCB结构体，包括进程号、状态、堆栈、Thread结构体、入口地址、next指针。
mymain.c（1）初始化所有进程，使成为循环链表：
#include "mypcb.h"
tPCB task[MAX_TASK_NUM]; //定义4个进程
tPCB * my_current_task = NULL;
volatile int my_need_sched = 0;
void my_process(void); //每10000000 来进行进程调度，调用my_schedule
void __init my_start_kernel(void)
{
int pid = 0;
int i;
task[pid].pid = pid; //0号进程pid设为0
task[pid].state = 0; //0号进程state设为可运行
task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;//0号进程的ip和入口地址设为my_process();
task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];//0号进程的栈顶为stack数组的最后一个元素
task[pid].next = &task[pid]; //next指针指向自己
for(i=1;i
（2）0号线程的启动：
asm volatile(
"movl %1,%%espnt" //esp指向stack数组的末尾
"pushl %1nt" //将task[0].thread.sp压栈
"pushl %0nt" //将task[0].thread.ip压栈
"retnt" //eip指向0进程起始地址，启动0号进程
"popl %%ebpnt" //释放栈空间
:
: "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)
myinterrupt.c
my_timer_handler 函数每隔1000产生一个中断并把 my_need_sched 设置为1，此时 mymain.c 中 my_process 函数调用my_schedule 调度程序进行进程切换。
- 时钟中断：
void my_timer_handler(void)
{
#if 1
if(time_count%1000 == 0 && my_need_sched != 1)
{
printk(KERN_NOTICE ">>>my_timer_handler here<< - 进程调度：
if(next->state == 0) //下一个进程可运行，执行进程切换
{
asm volatile(
"pushl %%ebpnt" //保存当前进程的ebp
"movl %%esp,%0nt" //将当前进程的esp储存到当前进程的thread.sp
"movl %2,%%espnt" //esp指向下一个进程
"movl $1f,%1nt" //将1f存储到thread.sp.$1f是“1:t”处,再次调度到该进程时就会从1:开始执行
"pushl %3nt" //将下一个进程的thread.ip压栈
"retnt" //eip指向下一个进程的起始地址
"1:t"
"popl %%ebpnt" //待下一个进程执行完后释放栈空间，恢复现场
: "=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<<pid,next->pid);
当下一个进程一次也没运行过，执行else后的语句：
else
{
next->state = 0;
my_current_task = next;
printk(KERN_NOTICE ">>>switch %d to %d<<pid,next->pid);
asm volatile(
"pushl %%ebpnt"
"movl %%esp,%0nt"
"movl %2,%%espnt"
"movl %2,%%ebpnt"
"movl $1f,%1nt"
"pushl %3nt"
"retnt"
: "=m" (prev->thread.sp),"=m" (prev->thread.ip)
: "m" (next->thread.sp),"m" (next->thread.ip)
);
}
思考：
- 相比if,else多了 "movl %2,%%ebpnt"，少了"popl %%ebpnt"，即将esp和ebp指向同一位置，并不恢复原进程，所以此部分是由于进程未运行过，所以要开始执行一个新进程；
- 此部分的"movl $1f,%1nt"是将进程原来的ip(my_process)替换为$1f,使得它被切换回来（运行状态）进入if，可从标号1：处继续执行；
- 为什么定义Thread时设置sp和ip保存esp和sip,而不设置bp来保存ebp呢？pushl $ebp压栈保存现场，popl $ebp出栈恢复现场，不需要单独设置变量来保存ebp就可完成，而eip和esp在进程切换中需要不停地变动，必须设置变量来保存。
总结：
操作系统内核从一个起始位置开始执行，完成初始化操作后，开始执行第一个进程。计算机为每个进程分配一个时间片，如果在时间片结束时进程仍在运行，该进程被阻塞，保存现场后切换到另一个进程，执行完后再返回原进程执行，从而完成进程调度。
