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

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

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

姓名：王玮怡  学号：20135116

第一节 函数调用堆栈

一、三个法宝

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

三、参数传递与局部变量

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>

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

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

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

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

代码执行大致过程：

（1）main进栈

（2）p1函数进栈

（3）return

（4）p2进栈

（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中的代码；

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

3、查看mymain.c（vi mymain.c），找到核心部分代码

修改完相关参数后，输入：wq保存退出；

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

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

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

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

1、举例：

说明：

（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）修饰符

2、练习 

分析：

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