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,其中也可以找到一个简单的时间片轮转多道程序内核代码
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 }
实验截图
黄伟业原创作品转载请注明出处《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000
Linux内核分析第二周:操作系统是如何工作的的更多相关文章
- Linux内核分析第二周--操作系统是如何工作的
Linux内核分析第二周--操作系统是如何工作的 李雪琦 + 原创作品转载请注明出处 + <Linux内核分析>MOOC课程http://mooc.study.163.com/course ...
- linux内核分析 第二周 操作系统是如何工作的
银雪纯 原创作品转载请注明出处 <Linux内核分析>MOOC课程http://mooc.study.163.com/course/USTC-1000029000 一.计算机是如何工作的 ...
- 20135327郭皓——Linux内核分析第二周 操作系统是如何工作的
操作系统是如何工作的 上章重点回顾: 计算机是如何工作的?(总结)——三个法宝 存储程序计算机工作模型,计算机系统最最基础性的逻辑结构: 函数调用堆栈,高级语言得以运行的基础,只有机器语言和汇编语言的 ...
- LINUX内核分析第二周学习总结——操作系统是如何工作的
LINUX内核分析第二周学习总结——操作系统是如何工作的 张忻(原创作品转载请注明出处) <Linux内核分析>MOOC课程http://mooc.study.163.com/course ...
- Linux内核设计第二周——操作系统工作原理
Linux内核设计第二周 ——操作系统工作原理 作者:宋宸宁(20135315) 一.实验过程 图1 执行效果 从图中可以看出,每执行my_ start_ kernel函数两次或一次,my_ time ...
- Linux内核分析第二周学习博客——完成一个简单的时间片轮转多道程序内核代码
Linux内核分析第二周学习博客 本周,通过实现一个简单的操作系统内核,我大致了解了操作系统运行的过程. 实验主要步骤如下: 代码分析: void my_process(void) { int i = ...
- linux内核分析第二周
网易云课堂linux内核分析第二周 20135103 王海宁 <Linux内核分析>MOOC课程http://mooc.study.163.com/cours ...
- Linux内核分析第二周学习笔记
linux内核分析第二周学习笔记 标签(空格分隔): 20135328陈都 陈都 原创作品转载请注明出处 <Linux内核分析>MOOC课程http://mooc.study.163.co ...
- Linux内核分析——第二周学习笔记20135308
第二周 操作系统是如何工作的 第一节 函数调用堆栈 存储程序计算机:是所有计算机基础的框架 堆栈:计算机中基础的部分,在计算机只有机器语言.汇编语言时,就有了堆栈.堆栈机制是高级语言可以运行的基础. ...
- Linux内核分析第二周学习总结:操作系统是如何工作的?
韩玉琪 + 原创作品转载请注明出处 + <Linux内核分析>MOOC课程http://mooc.study.163.com/course/USTC-1000029000 一.函数调用堆栈 ...
随机推荐
- python基本数据类型 数字 和 字符串
一.数字 int type可以查看数据类型 将字符串转换为数字: a=" b=int(a) print(type(a)) 以十六进制或者八进制或者二进制的形式转换为十进制: num ...
- <!DOCTYPE>标签与table高度100% (转)
<!DOCTYPE>标签可声明三种DTD类型,分别表示严格版本.过渡版本以及基于框架的 HTML 文档. 三种HTML文档类型: HTML 4.01 规定了三种文档类型:Strict.Tr ...
- Instruments模板介绍(更新中...)
第一章.Instruments(仪器)快速入门 Instruments可以用来收集关于一个或者多个系统进程的性能和行为的数据,并跟踪睡着时间产生的数据.它提供了好几个分析模板: Blank 任何类型都 ...
- Android 怎样开启与关闭adb 的认证机制(google adb secure) (adb RSA 指纹认证)
前言 欢迎大家我分享和推荐好用的代码段~~声明 欢迎转载,但请保留文章原始出处: CSDN:http://www.csdn.net ...
- centos7下安装docker(6镜像总结)
学了很长时间的镜像了,从镜像的分层,缓存的特性,到制作镜像:通过docker commint和docker build创建,再到制作dockerfile以及dockerfile中常用的参数FROM,M ...
- pku-2909 (欧拉筛)
题意:哥德巴赫猜想.问一个大于2的偶数能被几对素数对相加. 思路:欧拉筛,因为在n<215,在3万多,一个欧拉筛得时间差不多4*104, 那么筛出来的素数有4千多个,那么两两组合直接打表,时间复 ...
- 【SQL】sql update 多表关联更新方法总结
#表结构: 1.表一:Test1 Id name age 1 2 2.表二:Test2 Id name age 1 小明 10 2 小红 8 #实现将表Test2的name和age字段 ...
- ORB-SLAM2(2) ROS下配置和编译
1配置USB相机 1.1网友参考: http://www.liuxiao.org/2016/07/ubuntu-orb-slam2-%E5%9C%A8-ros-%E4%B8%8A%E7%BC%96%E ...
- FORWARD转发链的功能
B主机开启路由转发功能,相当一台路由器,
- poi导出excel,表头数据动态拼装
/* * 第一步:拼装表头和数据 */ // 放多个sheet的集合 List<Map<String,Object>> datas = new ArrayList<Map ...