《Linux内核分析》第二周学习小结 操作系统是如何工作的？

郝智宇   无转载   《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

一．函数调用堆栈：

1.计算机是如何工作的：

三个法宝：存储程序计算机、函数调用堆栈（堆栈机制是高级语言的起点）、中断机制。

2.堆栈作用：

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

3.堆栈寄存器（esp,ebp）和堆栈操作（push，pop）

其他关键寄存器：cs:eip（call，ret）

4.中断机制是如何工作的？

CPU很笨，只能从一个指令跳到另一个指令，中断机制是指计算机在执行一条指令的时候，调到另外一条指令执行，再跳回来还能接着执行原来的指令。

5.深入理解函数调用堆栈的工作机制：（看视频总结

函数调用时堆栈的变化，举例分析函数调用堆栈

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

1.Kernel实验背后涉及的思想：

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

2.利用mykernel实验模拟计算机硬件平台：

运行：

【一些说明】

打开mymain.c：

My_start_kernel ：操作系统的入口

每循环十万次，打印一个my_start_kernel。可以将十万改成一百万：

打开 Myinterrupt.c：

它每次时钟中断都调用一次printk，输出一次myinterrupt kernel。

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

1.C代码中嵌入汇编代码的写法：

内嵌汇编语法_asm_（

汇编语句模板：

输出部分：

输入部分：

变化描述部分）；

内嵌汇编常用限定符：

b,c,...     m:内存变量；    =：操作数在指令中是只写的；    +：操作数在指令中是读写类型的;   r：将输入变量放入通用寄存器，任一个；

2.一个简单的操作系统内核源代码

（1）进程的启动：

/* start process 0 by task[0] */
    pid = ;
    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 */    //因为栈为空，所以pushl的%1就是esp=ebp;
        "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*/
    );

（2）进程的切换：

有两种方式，分别是：

【1】next->state == 0（即下一个进程正在执行  在两个正在运行的进程之间做进程上下文切换）：

if(next->state == )/* -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"
            "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);
}

【2】进程是新的，还没有执行过：

else
    {
        next->state = ;
        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 */ //保存ebp;
            "movl %%esp,%0\n\t"     /* save esp */  //保存esp;
            "movl %2,%%esp\n\t"     /* restore  esp */    //将下一进程sp存入esp;
            "movl %2,%%ebp\n\t"     /* restore  ebp */   //将下一进程sp存入esp, 栈空，所以esp和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)
        );
    }

四. 关于操作系统是如何工作的的理解：

操作系统有“两把剑”，为中断上下文和进程上下文的切换，有了这两把剑，操作系统便能够有序地管理进程。

多道程序中断发生时，cpu把当前的进程中断，，然后指向中断处理程序的入口。操作系统会判断何时进行进程切换、什么条件下进行切换。因为是时间片轮转，所以需要设置时间片的大小，时间片用完时设置一下调度标志。例如循环1000万次才有一次机会判断一下是否需要调度，如果是的话就进行切换。