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

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

《Linux内核分析》 之 操作系统是如何工作的

第一讲 函数调用堆栈

计算机是如何工作的？（总结）——三个法宝

1,存储程序计算机工作模型，计算机系统最最基础性的逻辑结构；

2,函数调用堆栈，高级语言得以运行的基础，只有机器语言和汇编语言的时候堆栈机制对于计算机来说并不那么重要，但有了高级语言及函数，堆栈成为了计算机的基础功能；

enter

pushl %ebp

movl %esp,%ebp

leave

movl %ebp,%esp

popl %ebp

函数参数传递机制和局部变量存储

3,中断，多道程序操作系统的基点，没有中断机制程序只能从头一直运行结束才有可能开始运行其他程序。

堆栈是c语言程序运行时必须的一个记录调用路径和参数的空间

-函数调用框架

-传递参数

-保存返回地址

-提供局部变量空间

堆栈相关的寄存器

-esp，堆栈指针(stack pinter)

-ebp，基址指针（base pointer)（高地址）

堆栈操作

-push

栈顶地址减少4个字节（32位）

-pop

栈顶地址增加4个字节

ebp在C语言中用作记录当前函数调用基址

其他关键寄存器

-cs:eip:总是指向下一条的指令地址

2.参数传递过程

下面的代码中有参数传递过程：

#include

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

}

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

mykernel实验指导（操作系统是如何工作的）

使用实验楼的虚拟机打开shell

cd LinuxKernel/linux-3.9.4

qemu -kernel arch/x86/boot/bzImage

然后cd mykernel 您可以看到qemu窗口输出的内容的代码mymain.c和myinterrupt.c

使用自己的Linux系统环境搭建过程参见mykernel,其中也可以找到一个简单的时间片轮转多道程序内核代码

实验要求：

• 完成一个简单的时间片轮转多道程序内核代码，代码见视频中或从mykernel找。

• 详细分析该精简内核的源代码并给出实验截图，撰写一篇署名博客，并在博客文章中注明“真实姓名（与最后申请证书的姓名务必一致） + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000 ”，博客内容的具体要求如下：

o 题目自拟，内容围绕操作系统是如何工作的进行；

o 博客中需要使用实验截图

o 博客内容中需要仔细分析进程的启动和进程的切换机制

o 总结部分需要阐明自己对“操作系统是如何工作的”理解。

实验截图



参看实验代码：

•查看mymain.c



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

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

• 截图





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

1.mypcb.h//头文件

10 #define MAX_TASK_NUM 4

11 #define KERNEL_STACK_SIZE 1024*8

12

13 /* CPU-specific state of this task */

14 struct Thread {

15 unsigned long ip;

16 unsigned long sp;

17 };

18

19 typedef struct PCB{

20 int pid;

21 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped /

22 char stack[KERNEL_STACK_SIZE];

23 / CPU-specific state of this task /

24 struct Thread thread;

25 unsigned long task_entry;

26 struct PCB next;

27 }tPCB;

28

29 void my_schedule(void);

2.mymain.c

16 #include "mypcb.h"

17

18 tPCB task[MAX_TASK_NUM];

19 tPCB * my_current_task = NULL;

20 volatile int my_need_sched = 0;

21

22 void my_process(void);

23

24

25 void __init my_start_kernel(void)

26 {

27 int pid = 0;

28 int i;

29 /* Initialize process 0*/

30 task[pid].pid = pid;

31 task[pid].state = 0;

32 task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;

33 task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];

34 task[pid].next = &task[pid];

35 /fork more process /

36 for(i=1;i<MAX_TASK_NUM;i++)

37 {

38 memcpy(&task[i],&task[0],sizeof(tPCB));

39 task[i].pid = i;

40 task[i].state = -1;

41 task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];

42 task[i].next = task[i-1].next;

43 task[i-1].next = &task[i];

44 }

45 /* start process 0 by task[0] /

46 pid = 0;

47 my_current_task = &task[pid];

48 asm volatile(

49 "movl %1,%%esp\n\t" / set task[pid].thread.sp to esp /

50 "pushl %1\n\t" / push ebp /

51 "pushl %0\n\t" / push task[pid].thread.ip /

52 "ret\n\t" / pop task[pid].thread.ip to eip /

53 "popl %%ebp\n\t" //弹出来ebp,内核初始化工作完成

54 :

55 : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) / input c or d mean %ecx/%edx*/

56 );

57 }

58 void my_process(void)

59 {

60 int i = 0;

61 while(1)

62 {

63 i++;

64 if(i%10000000 == 0)

65 {

66 printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);

67 if(my_need_sched == 1) //执行10 000 000次才判断一次是否需要调度

68 {

69 my_need_sched = 0;

70 my_schedule();

71 }

72 printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);

73 }

74 }

75 }

3.myinterrupt.c 调度机制

15 #include "mypcb.h"

16

17 extern tPCB task[MAX_TASK_NUM];

18 extern tPCB * my_current_task;

19 extern volatile int my_need_sched;

20 volatile int time_count = 0;

21

22 /*

23 * Called by timer interrupt.

24 * it runs in the name of current running process,

25 * so it use kernel stack of current running process

26 */

27 void my_timer_handler(void)

28 {

29 #if 1

30 if(time_count%1000 == 0 && my_need_sched != 1)

31 {

32 printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");

33 my_need_sched = 1;

34 }

35 time_count ++ ;

36 #endif

37 return;

38 }

39

40 void my_schedule(void)

41 {

42 tPCB * next;

43 tPCB * prev;

44

45 if(my_current_task == NULL

46 || my_current_task->next == NULL)

47 {

48 return;

49 }

50 printk(KERN_NOTICE ">>>my_schedule<<<\n");

51 /* schedule */

52 next = my_current_task->next;

53 prev = my_current_task;

54 if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped / //在两个正在执行的进程之间做上下文切换

55 {

56 / switch to next process /

57 asm volatile(

58 "pushl %%ebp\n\t" / save ebp /

59 "movl %%esp,%0\n\t" / save esp /

60 "movl %2,%%esp\n\t" / restore esp /

61 "movl $1f,%1\n\t" / save eip / //$1f就是指标号1:的代码在内存中存储的地址

62 "pushl %3\n\t"

63 "ret\n\t" / restore eip /

64 "1:\t" / next process start here */

65 "popl %%ebp\n\t"

66 : "=m" (prev->thread.sp),"=m" (prev->thread.ip)

67 : "m" (next->thread.sp),"m" (next->thread.ip)

68 );

69 my_current_task = next;

70 printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid

71 }

72 else

73 {

74 next->state = 0;

75 my_current_task = next;

76 printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);

77 /* switch to new process /

78 asm volatile(

79 "pushl %%ebp\n\t" / save ebp /

80 "movl %%esp,%0\n\t" / save esp /

81 "movl %2,%%esp\n\t" / restore esp /

82 "movl %2,%%ebp\n\t" / restore ebp /

83 "movl $1f,%1\n\t" / save eip /

84 "pushl %3\n\t"

85 "ret\n\t" / restore eip */

86 : "=m" (prev->thread.sp),"=m" (prev->thread.ip)

87 : "m" (next->thread.sp),"m" (next->thread.ip)

88 );

89 }

90 return;

91 }

总结：

通过本星期的学习我了解了计算机工作的三法宝。

回想上一学期学的操作系统知识，更深人的了解了进程的中断和切换。