《Linux内核分析》第二周学习报告

时间:2021-10-27 14:52:55

《Linux内核分析》第二周学习报告

——操作系统是如何工作的

姓名:王玮怡  学号:20135116

第一节 函数调用堆栈

一、三个法宝

《Linux内核分析》第二周学习报告

二、深入理解函数调用堆栈

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

三、参数传递与局部变量

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>

《Linux内核分析》第二周学习报告

add $0x8,%esp //清除call之前的内容

mov %eax,0xfffffffc(%ebp) //函数的返回值通过eax寄存器传递

printf("%d=%d+%d\n",z,x,y) //依次push y、x、z,最后push常量字串

《Linux内核分析》第二周学习报告

sub $0x18,%esp //新建一个指定大小的堆栈空间来存储局部变量

代码执行大致过程:

(1)main进栈

(2)p1函数进栈

《Linux内核分析》第二周学习报告

(3)return

《Linux内核分析》第二周学习报告

(4)p2进栈

《Linux内核分析》第二周学习报告

(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中的代码;

《Linux内核分析》第二周学习报告

2、进入mykernel查看代码,包括mymain.c和myinterrupt.c;

3、查看mymain.c(vi mymain.c),找到核心部分代码

《Linux内核分析》第二周学习报告

修改完相关参数后,输入:wq保存退出;

4、查看myinterrupt.c,找到核心部分代码

《Linux内核分析》第二周学习报告

每次时钟中断都调用一次printk。

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

一、C代码嵌入汇编代码的写法

《Linux内核分析》第二周学习报告

1、举例:

《Linux内核分析》第二周学习报告

说明:

(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)修饰符

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

《Linux内核分析》第二周学习报告

2、练习 
《Linux内核分析》第二周学习报告

分析:

(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操作系统的工作原理。首先,计算机工作有三大法宝,包括存储程序计算机、函数调用堆栈以及中断机制。另外,进程的实质就是堆栈,进程切换也就是堆栈之间的切换,所以操作系统就是通过不同进程的不断切换来完成工作的。操作系统的“两把剑”:中断上下文和进程上下文的切换。其中中断上下文也就是保存现场和恢复现场。这次的学习内容对我来说难度很大,在听课的过程中理解起来也十分困难。但是感觉有了上一周的基础,基本可以做到自己分析简单的汇编代码。