完成一个简单的时间片轮转多道程序内核代码
基本概念
1.计算机的三个法宝：a.存储程序计算机；b.函数调用堆栈；c.中断
存储程序计算机：所有计算机的基础性的逻辑框架
函数调用堆栈:C语言程序运行时必须使用的记录函数调用路径和参数存储的空间
堆栈具体的作用：
- 记录函数调用框架
- 传递函数参数
- 保存返回值的地址
- 提供函数内部局部变量的存储空间
堆栈相关的寄存器：
- ESP：堆栈指针
- EBP：基址指针
堆栈操作：
- push：栈顶地址减少4个字节，并将操作数放进栈顶存储单元
- pop：栈顶地址增加4个字节，并将栈顶存储单元的内容放入操作数
其他关键寄存器：
- CS:EIP：总是指向地址连续的下一条指令
- 跳转/分支：执行这样的命令时，CS:EIP的值会根据程序需要被修改
- call：将当前CS:EIP的值压入栈顶，CS:EIP指向被调用函数的入口地址
- ret：从栈顶弹出原来保存在这里CS:EIP的值，放入CS:EIP中
mykernel的搭建
- Set up this platform:
由于这一步：
wget https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.9.4.tar.xz下载太慢，我直接在Windows环境下下载并复制粘贴到虚拟机中
其中：
wget https://raw.github.com/mengning/mykernel/master/mykernel_for_linux3.9.4sc.patch
改成这样：
wget https://github.com/mengning/mykernel/blob/master/mykernel_for_linux3.9.4sc.patch可以下载到patch文件
出现问题：
对tar.xz结尾的压缩文件进行解压，如下：
$xz -d ***.tar.xz
$tar -xvf ***.tar此种方式会造成原来的*.tar.xz压缩包不存在，可以看到这个压缩包也是打包后再压缩，外面是xz压缩方式，里层是tar打包方式。
可直接使用一条命令进行解压缩：
tar xvJf ***.tar.xz 来解压
-- 引用自风去沙来
解压结果：
给Ubuntu装make:
这句开始出现问题：
试试添加补丁：
diff -Naur linux-3.9.4 linux-3.9.4.new/ > mykernel_for_linux3.9.4sc.patch
应该是从解压还是出现问题的，删除解压文件重新解压：
结果还是有这样的问题：
是否因为：
1.文件有问题
2.解压命令错误
有人说，查阅资料后发现问题，是在下载安装包的时候，安装包没有下载完整，重新再一次下载安装包后，重新解压则成功。
再次下载，中间因为网速中断了好几次，使用以下命令可以从中断处继续下载：
wget -c https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.9.4.tar.xz终于，解压过程没有出现任何错误！这里用的解压命令是：
$xz -d ***.tar.xz
$tar -xvf ***.tar但是这个问题依然存在
后来发现
wget https://github.com/mengning/mykernel/blob/master/mykernel_for_linux3.9.4sc.patch是可以下到文件，但是内容不对,所以我在虚拟机环境下直接复制粘贴下了patch代码。如果是真实情况，可以通过共享文件实现复制粘贴。
再试试：
这样应该是没什么问题了。
make allnoconfig也很顺利
make这里又出现问题了
实验楼下实现过程：
mypcb.h的源代码：
修改后的mymain.c：
修改后的myinterrupt.c：
修改后的内核启动图：
实验代码分析
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;
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);mymain.c
/*
* linux/mykernel/mymain.c
*
* Kernel internal my_start_kernel
*
* Copyright (C) 2013 Mengning
*
*/
#include
#include
#include
#include
#include
#include "mypcb.h"
tPCB task[MAX_TASK_NUM];
tPCB * my_current_task = NULL;
volatile int my_need_sched = 0; /*是否需要调度的标志*/
void my_process(void);
void __init my_start_kernel(void) /*内核入口。初始化并启动0号进程*/
{
int pid = 0;
int i;
/* Initialize process 0*/
task[pid].pid = pid;
task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped */
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;ipid);
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
#include
#include
#include
#include
#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; /*调度执行my_schedule(void)*/
}
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 */
{
my_current_task = next;
printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);
/* 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"
: "=m" (prev->thread.sp),"=m" (prev->thread.ip)
: "m" (next->thread.sp),"m" (next->thread.ip)
);
}
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;
} 总结
1.Linux操作系统的正常工作可以说有三个非常重要的部分，就是我们的存储程序原理、堆栈以中断的支持。 操作系统对进程的管理主要就是进程的管理和调度，我们为每个进程维护一个进程描述和以及进程间的关系。我们的内核的工作主要有两部分组成，首先运行有一个内核线程，然后就是一些中断处理程序的集合，我们在中断处理程序中要就行进程的调度。
2.Linux操作系统由内核来实现具体工作的，一个进程是通过系统调用fork（）函数来创建的，先是将先前CPU正在运行的进程的进程上下文保存在内核态堆栈中，包括有eip,esp,ebp,cs等寄存器的数据；然后加载创建的进程的上下文信息到相应的寄存器中，运行当前新建进程；运行完毕后根据系统的调度继续执行相应的进程。Linux操作系统是多进程的操作系统，不同的进程就是基于以上的方式有操作系统实现调度运行的。同时，操作系统以一种中断的机制实现与用户的交互。操作系统中的IDT描述好各个中断对应的处理程序，当发生相对应的中断时，由硬件来实现中断信号的传递，CPU接收到相应的IRQ信号后，由操作系统如调度进程那样调度相应的处理程序，来完成相应的中断请求，实现与用户的交互。