《Linux内核分析》第二周学习笔记

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

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

1. 前言

计算机是如何工作的？

三个法宝：

• 存储程序计算机：所有计算机基础性的逻辑框架。
• 堆栈：高级语言的起点，函数调用需要堆栈机制。
• 中断机制：多道系统的基础，是计算机效率提升的关键。

2. 函数调用堆栈

2.1 堆栈

堆栈是C语言程序运行时必须的一个记录调用路径和参数的空间，即CPU内已经集成好了很多功能。堆栈含以下元素：

• 函数调用框架
• 传递参数
• 保存返回地址（%eax）
• 提供局部变量空间
• 等等

C语言编译器对堆栈的使用有一套的规则。

了解堆栈存在的目的和编译器对堆栈使用的规则是理解操作系统一些关键性代码的基础。

2.2 堆栈相关的寄存器

• esp，堆栈指针
• ebp，基址指针

2.3 堆栈操作

• push，栈顶地址减少4个字节（32位）
• pop，栈顶地址增加4个字节

注：ebp在C语言中用做记录当前函数调用基址。

2.4 其他关键寄存器

cs:eip：指向地址连续的下一条指令

• 顺序执行：总是指向地址连续的下一条指令
• 跳转/分支：执行这样的指令的时候，cs:eip的值会根据程序需要被修改
• call：将当前cs:eip的值压入栈顶，cs:eip指向被调用函数的入口地址
• ret：从栈顶弹出原来保存在这里的cs:eip的值，放入cs:eip中
• 发生中断时……

2.5 深入理解函数调用堆栈的工作机制

如图，将函数调用变成在CPU上的顺序直流。

调用函数就是建立一个新堆栈。

2.6 参数传递

例：

#include <stdio.h>
void p1(char c)
{
    printf("%c",c);
}
int p2(int x,int y)
{
    return x+y;
}
int main(void)
{
    char c ='a';
    int x,y;
    x =1;
    y =2;
    p1(c);
    z = p2(x,y);
    printf("%d = %d+%d",z,x,y);
}

z = p2(x,y)如何传递参数给p2

pushl 0xfffffff8(%ebp) //将y的值压入栈（为什么不是pushl y而是采用变址寻址的方式呢？因为x、y的值是局部变量，已经被保存在堆栈中了，所以可用变址寻址的方式找到）
pushl 0xfffffff4(%ebp) //将x的值压入栈
call 804839b<p2> //调用函数
add $0x8,%esp //之前压入栈的x、y还在当前栈中，让x、y出栈。有压栈必有出栈
mov %eax,0xfffffffc(%ebp) //用%eax暂存p2的返回值，0xfffffffc(%ebp)的位置上放置的是z，即这句指令将返回值赋给z

printf("%d=%d+%d\n",z,x,y);

pushl 0xfffffff8(%ebp) //从后向前依次push y、x、z、常量字串
pushl 0xfffffff4(%ebp)
pushl 0xfffffffc(%ebp)
push $0x8048510 //将内存地址的内容压入堆栈
call 80482b0<printf@plt>
……

2.7 局部变量

main函数的局部变量存储机制

现在的编译器不强制要求局部变量必须在函数头部

注：

sub $0x18,%esp //在堆栈中为存储局部变量预留空间

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

3.1 利用mykernel实验模拟计算机硬件平台

• 搭建一个虚拟的X86CPU，使用Linux源代码将这个系统配置好，通过程序执行入口执行程序。
• 当一个中断信号发生的时候，CPU把当前的esp,ebp,eip压入内核堆栈中，然后让eip指向中断处理程序入口去处理中断。在该系统中使用的是时钟中断，即每隔一段时间发生一次中断。

3.2 实验过程

由图可知：每执行my_ start_ kernel函数一次或两次，my_ time_ hander函数就执行一次。

mymain.c ——系统中唯一的进程

mystartkernel之前的都是硬件初始化的工作，之后是整个操作系统的入口，开始执行操作系统。其中代码完成的工作是每循环10000次，打印一句话。

myinterrupt.c ——时间中断处理程序

每执行一次，都会执行一次时钟中断，每次时钟中断都调用printk并输出。

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

4.1 C代码中嵌入汇编代码的写法

• 语法格式

• 例子

%%eax中的第一个%表示转义字符。

%1是特殊符号，指下面输出、输入部分的变量按照0、1、2……编号后被取出。

"=m"表示写入内存变量，即把eax的值放到内存变量val3中。

• 内嵌汇编常用限定符

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

　　分析进程的启动和进程的切换机制（分析见注释）

• mypcb.h（头文件，定义进程控制块等）

  /*
   *  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; //eip
      unsigned long       sp; //esp
  };
  
  typedef struct PCB{
      int pid; //定义进程的IP
      volatile long state;    /* 定义进程的状态：-1 不可运行, 0 可运行, >0 停止 */
      char stack[KERNEL_STACK_SIZE]; //内核堆栈
  
      struct Thread thread;
      unsigned long   task_entry; //指定进程入口
      struct PCB *next; //进程链表
  }tPCB;
  
  void my_schedule(void); //声明调度器函数
  

• mymain.c 内核初始化和0号进程启动

  /*
   *  linux/mykernel/mymain.c
   *
   *  Kernel internal my_start_kernel
   *
   *  Copyright (C) 2013  Mengning
   *
   */
  #include <linux/types.h>
  #include <linux/string.h>
  #include <linux/ctype.h>
  #include <linux/tty.h>
  #include <linux/vmalloc.h>
  
  #include "mypcb.h"
  
  tPCB task[MAX_TASK_NUM]; //声明一个tPCB结构的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*/
      task[pid].pid = pid; //先初始化0号进程的数据结构
      task[pid].state = 0;/* 状态：-1 不可运行, 0 可运行, >0 停止 */
      task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process; //进程入口是my_process
      task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1]; //堆栈的栈顶位置
      task[pid].next = &task[pid]; //下一个进程还是指向自己，因为刚启动时只有0号进程）
  
      /* 创建更多的子进程 */
      for(i=1;i<MAX_TASK_NUM;i++)
      {
          memcpy(&task[i],&task[0],sizeof(tPCB)); //copy 0号进程的状态，需要修改的地方再修改
          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];
      }
      /* 启动0号进程 */
      pid = 0;
      my_current_task = &task[pid];
      asm volatile(
          "movl %1,%%esp\n\t"     /* %1代表task[pid].thread.sp，设置 esp 的值 */
          "pushl %1\n\t"          /* 将 ebp 压栈（此时空栈esp=ebp）*/
          "pushl %0\n\t"          /* ，%0代表task[pid].thread.ip，即将 eip 压栈 */
          "ret\n\t"               /* eip 出栈 */
          "popl %%ebp\n\t" //弹出ebp,内核初始化工作完成，0号进程正式启动
          :
          : "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);
          }
      }
  }
  

• myinterrupt.c(调度机制)

  /*
   *  linux/mykernel/myinterrupt.c
   *
   *  Kernel internal my_timer_handler
   *
   *  Copyright (C) 2013  Mengning
   *
   */
  #include <linux/types.h>
  #include <linux/string.h>
  #include <linux/ctype.h>
  #include <linux/tty.h>
  #include <linux/vmalloc.h>
  
  #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) //设置时间片的大小，时间片用完时设置一下调度标志。只要满足上述两个条件，就将my_need_sched设为1，这样mymain.c循环到这个进程的时候就可以对这个进程进行调度
      {
          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; //将当前进程的下一个进程赋给next
      prev = my_current_task;
      if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
      {
          //在两个正在执行的进程之间做上下文切换
          asm volatile(
              "pushl %%ebp\n\t"       /* 保存当前进程的ebp */
              "movl %%esp,%0\n\t"     /* 保存当前进程的esp */
              "movl %2,%%esp\n\t"     /* 重新记录要跳转进程的esp，将下一进程中的sp放入esp中 */
              "movl $1f,%1\n\t"       /* $1f指标号1:的代码在内存中存储的地址，即保存当前的eip */
              "pushl %3\n\t"  //将下一进程的eip压入栈，%3为 next->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 //进程是还没执行过的新进程
      {
          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"       /* 保存当前进程的ebp */
              "movl %%esp,%0\n\t"     /* 保存当前进程的esp */
              "movl %2,%%esp\n\t"     /* 重新记录要跳转进程的esp */
              "movl %2,%%ebp\n\t"     /* 重新记录要跳转进程的ebp */
              "movl $1f,%1\n\t"       /* 保存当前eip  */
              "pushl %3\n\t"
              "ret\n\t"               /* 重新记录要跳转进程的eip */
              : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
              : "m" (next->thread.sp),"m" (next->thread.ip)
          );
      }
      return;
  }
  

4.3 运行这个精简的内核

该操作系统内核程序在虚拟机中启动时的结果为：0、1、2、3号进程循环切换执行。

操作系统的“两把剑”——中断上下文、进程上下文的切换

5. 总结

操作系统是如何工作的？

• 操作系统是建立在硬件基础上的、管理电脑硬件与软件资源的程序，同时也是计算机系统的基础。
• 操作系统能够有条不紊地处理多个计算机的进程的关键是中断上下文和进程切换。
• 操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源;控制程序运行;改善人机界面;为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便有效的服务界面。
• 操作系统是一个庞大的管理控制程序，大致包括5个方面的管理功能:进程与处理机管理、作业管理、存储管理、设备管理、文件管理。