自制操作系统内核：函数调用堆栈与时间片轮转调度-CSDN博客

本文链接：https://blog.csdn.net/jess_Jung/article/details/120691368

一，mykernel 实验：

1.深度理解函数调用堆栈：

上周已经一步步地分析过含有变量的函数调用时堆栈的变化，现在对堆栈框架进行一些补充，以以下程序为例：

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.h

struct 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<MAX_TASK_NUM;i++)                          //1,2,3号进程复制0号进程
    {
        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];                       //当前运行的进程设为0号进程
    );
}

（2）0号线程的启动：

 asm volatile(
        "movl %1,%%esp\n\t"     //esp指向stack数组的末尾
        "pushl %1\n\t"          //将task[0].thread.sp压栈
        "pushl %0\n\t"          //将task[0].thread.ip压栈
        "ret\n\t"               //eip指向0进程起始地址，启动0号进程
        "popl %%ebp\n\t"        //释放栈空间
        : 
        : "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<<<\n");
        my_need_sched = 1;
    } 
    time_count ++ ;  
#endif
    return;      
}

进程调度：

if(next->state == 0)                  //下一个进程可运行，执行进程切换
    {
        /* switch to next process */   
        asm volatile(    
            "pushl %%ebp\n\t"           //保存当前进程的ebp
            "movl %%esp,%0\n\t"         //将当前进程的esp储存到当前进程的thread.sp
            "movl %2,%%esp\n\t"         //esp指向下一个进程
            "movl $1f,%1\n\t"           //将1f存储到thread.sp.$1f是“1:\t”处,再次调度到该进程时就会从1:开始执行
            "pushl %3\n\t"              //将下一个进程的thread.ip压栈
            "ret\n\t"                   //eip指向下一个进程的起始地址
            "1:\t"                      
            "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后的语句：

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)
        );          
    }

思考：

相比if,else多了 "movl %2,%%ebp\n\t"，少了"popl %%ebp\n\t"，即将esp和ebp指向同一位置，并不恢复原进程，所以此部分是由于进程未运行过，所以要开始执行一个新进程；
此部分的"movl $1f,%1\n\t"是将进程原来的ip(my_process)替换为$1f,使得它被切换回来（运行状态）进入if，可从标号1：处继续执行；
为什么定义Thread时设置sp和ip保存esp和sip,而不设置bp来保存ebp呢？pushl $ebp压栈保存现场，popl $ebp出栈恢复现场，不需要单独设置变量来保存ebp就可完成，而eip和esp在进程切换中需要不停地变动，必须设置变量来保存。