一 实验过程及效果
1.准备好相关的代码，分别是mymain.c,mypcb.h,myinterrupt.c ，如下图，make
make成功：
在qemu创建的虚拟环境下的运行效果：（使用的命令如上图所示）
效果分析：可以看到进程在不断切换，分别有进程0，1，2，3，每隔一段时间就进行一次切换。
二 具体代码
mypcb.h
#define MAX_TASK_NUM 4 //定义最大任务（进程数）
#define KERNEL_STACK_SIZE 1024*8 //定义内核堆栈的大小 struct Thread{
unsigned long ip;
unsigned long sp;
}; typedef struct PCB{ //定义进程控制块
int pid;
volatile long state;
char stack[KERNEL_STACK_SIZE]; struct Thread thread;
unsigned long task_entry;
struct PCB *next; }tPCB; void my_schedule(void); //声明调度函数
mypcb.h
mymain.c
#include <linux/types.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <linux/stackprotector.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
#include <linux/acpi.h>
#include <linux/tty.h>
#include <linux/percpu.h>
#include <linux/kmod.h>
#include <linux/vmalloc.h>
#include <linux/kernel_stat.h>
#include <linux/start_kernel.h>
#include <linux/security.h>
#include <linux/smp.h>
#include <linux/profile.h>
#include <linux/rcupdate.h>
#include <linux/moduleparam.h>
#include <linux/kallsyms.h>
#include <linux/writeback.h>
#include <linux/cpu.h>
#include <linux/cpuset.h>
#include <linux/cgroup.h>
#include <linux/efi.h>
#include <linux/tick.h>
#include <linux/interrupt.h>
#include <linux/taskstats_kern.h>
#include <linux/delayacct.h>
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
#include <linux/buffer_head.h>
#include <linux/page_cgroup.h>
#include <linux/debug_locks.h>
#include <linux/debugobjects.h>
#include <linux/lockdep.h>
#include <linux/kmemleak.h>
#include <linux/pid_namespace.h>
#include <linux/device.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/idr.h>
#include <linux/kgdb.h>
#include <linux/ftrace.h>
#include <linux/async.h>
#include <linux/kmemcheck.h>
#include <linux/sfi.h>
#include <linux/shmem_fs.h>
#include <linux/slab.h>
#include <linux/perf_event.h>
#include <linux/file.h>
#include <linux/ptrace.h>
#include <linux/blkdev.h>
#include <linux/elevator.h> #include <asm/io.h>
#include <asm/bugs.h>
#include <asm/setup.h>
#include <asm/sections.h>
#include <asm/cacheflush.h> #ifdef CONFIG_X86_LOCAL_APIC
#include <asm/smp.h>
#endif #include"mypcb.h" tPCB task[MAX_TASK_NUM];
tPCB * my_current_task = NULL;
volatile int my_need_sched = ; //定义调度标志 void my_process(void); void __init my_start_kernel(void) //进程初始化，并使进程0开始运行
{
int pid=;
int i ; /*进程0初始化*/ task[pid].pid = pid;
task[pid].state = ;
task[pid].task_entry = task[pid].thread.ip = (unsigned long) my_process; //指定进程0的入口
task[pid].thread.sp=(unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-];
task[pid].next = &task[pid];
for(i=;i<MAX_TASK_NUM;i++) //初始化进程1，2，3
{
memcpy(&task[i],&task[],sizeof(tPCB));
task[i].pid = i;
task[i].state = -; /* -1 unrunnable, 0 runnable, >0 stopped */
task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-];
task[i].next = task[i-].next; //构建进程控制块链表
task[i-].next = &task[i]; } pid = ;
my_current_task = &task[pid];
asm volatile( //嵌入式汇编代码，使进程0运行起来
"movl %1,%%esp\n\t"
"pushl %1\n\t"
"pushl %0\n\t"
"ret \n\t"
"popl %%ebp\n\t"
:
:"c" (task[pid].thread.ip),"d" (task[pid].thread.sp) );
/* while(1)
{
i++;
if(i%100000 == 0)
printk(KERN_NOTICE "my_start_kernel here %d \n",i); }*/
} void my_process(void) //进程的处理任务，每个进程都一样
{
int i = ;
while() //死循环
{
i++;
if(i% == ) //每10000000个指令周期检测一次是否调度
{
printk(KERN_NOTICE "THIS IS PROCESS %d -\n ",my_current_task->pid);
if(my_need_sched == )
{
my_need_sched =;
my_schedule(); //发生调度
}
printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid); } }
}
mymian.c
myinterrupt.c
#include <linux/kernel_stat.h>
#include <linux/export.h>
#include <linux/interrupt.h>
#include <linux/percpu.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/pid_namespace.h>
#include <linux/notifier.h>
#include <linux/thread_info.h>
#include <linux/time.h>
#include <linux/jiffies.h>
#include <linux/posix-timers.h>
#include <linux/cpu.h>
#include <linux/syscalls.h>
#include <linux/delay.h>
#include <linux/tick.h>
#include <linux/kallsyms.h>
#include <linux/irq_work.h>
#include <linux/sched.h>
#include <linux/sched/sysctl.h>
#include <linux/slab.h> #include <asm/uaccess.h>
#include <asm/unistd.h>
#include <asm/div64.h>
#include <asm/timex.h>
#include <asm/io.h> #define CREATE_TRACE_POINTS
#include <trace/events/timer.h> #include "mypcb.h" extern tPCB task[MAX_TASK_NUM];
extern tPCB * my_current_task;
extern volatile int my_need_sched;
volatile int time_count = ; /******* Called by timer interrupt.******/ void my_timer_handler(void) //定时器中断的调用函数
{
#if 1
if(time_count% == && my_need_sched != )
{
printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
my_need_sched = ;
}
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");
//开始调度
next = my_current_task->next;
prev = my_current_task;
if(next->state == )/* -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"
"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
{ //如果下一任务（进程）不为0，从未被调度过
next->state = ;
my_current_task = next;
printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);
asm volatile(
"pushl %%ebp\n\t"
"movl %%esp,%0\n\t"
"movl %2,%%esp\n\t"
"movl %2,%%ebp\n\t"
"movl $1f,%1\n\t"
"pushl %3\n\t"
"ret \n\t"
: "=m" (prev->thread.sp),"=m" (prev->thread.ip)
: "m" (next->thread.sp),"m" (next->thread.ip) ); }
return;
}
myinterrupt.c
三 代码以及原理分析
在代码的已经进行了简要的注释，下面进行分析：首先在mypcb.h文件中定义了进程控制块的结构体 ，其中成员pid代表的是进程号（在内核中唯一标识一个进程），state代表进程的状态，为了简化，并没有列出我们在操作系统中学到的所有的进程状态，0代表运行态，-1非运行态，>0停止态，“struct Thread thread;”定义了进程堆栈操作相关的寄存器；“task_entry;”定义了进程的入口，即具体的处理函数；“struct PCB *next;”定义指向下一进程的指针。首先通过“void __init my_start_kernel(void)”进行初始化0号进程，指定了进程0的入口my_process();并且初始化进程1，2，3，构建了进程链表，接下来用嵌入式汇编使进程运行起来，即执行my_process()函数，可以看到函数内部有个while(1)死循环，每10000000个周期打印进程号信息、检测一次是否发生了调度，如果发生了调度，清除调度的标识my_need_sched，（就是使本进程能够被抢占，相当于清信号量的意思）就执行调度函数my_schedule();调度的标识 my_need_sched在哪里发生改变呢？这涉及到定时器中断了——在my_interrupt.c文件可以看到“void my_timer_handler(void)”，这就是定时器中断的处理函数，当定时中断次数达到1000次时，改变一次调度标志 ，表示能够调度了（主动调度），接下来就是调度函数进行调度了，其中的两段嵌入式汇编就是调度的关键，本质就是修改eip，指向要调度的函数入口，并进行进程上下文的保存（堆栈的方式）。后面就是无限循环了， 每10000000个周期检测一次是否发生了调度，这在期间定时器中断修改调度标识，使能发生调度。。。。。。
总结：个人对“操作系统如何工作的理解”
操作系统是对硬件的抽象，摆脱了用户直接操作硬件（否则想要用电脑之前必须成为编程高手），所以操作系统在电脑大众化的过程中扮演了不可磨灭的角色。同时操作系统是对硬件的最大化利用，在多用户系统中，使每个用户感觉自己在独享电脑；在多任务系统中，使每个进程（任务）感觉自己在霸占cpu。。。闲话不多说，要想要操作系统实现上述的功能（不发生混乱的局面），必须安排好调度机制，一种机制就是时间片轮转机制，就是多用户或者多任务轮流使用cpu，且使用时间有限，时间到了必须让出cpu，但是谁能担当这个安排时间角色呢？这就需要硬件的帮忙——定时器，当设定好规定时间后，当定时的时间到了，就以中断（异步）方式通知cpu作出相应的动作。。。。这是这种机制使计算机有序完成各种任务——任务管理，内存管理，文件管理，I/O设备管理等。
声明：1.实验环境基于网易实验平台——实验楼的64位linux环境。
2. 代码借鉴了孟宁老师的代码。
3.错误之处恳请指导~~~
by：方龙伟
原创作品 转载请注明出处
《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000