内核分析 第二周

基本数据结构

/* 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;

内核启动

1. 在 linux-3.9.4/include/linux/start_kernel.h 增加外部声明 void __init my_start_kernel(void)
2. 在 linux-3.9.4/init/main.c 中的 start_kernel 函数中调用 my_start_kernel

由此可见, start_kernel 函数担任了内核初始化工作.

my_start_kernel 函数具体实现是在 mymain.c 进行初始化工作.

void __init my_start_kernel(void)
{int pid = 0;//初始j进程 pid 为 0task[pid].pid = pid;//状态为 runnabletask[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];//类似上面初始化工作. 用 task[0] 初始化 task[1] task[2] ..//task[MAX_TASK_NUM-1]. 但修改进程 pid, state, stack, nextint i;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[1].next = task[0].next; task[0].next = task[1]task[2].next = task[1].next; task[1].next = task[2]...将所有进程通过有环链表连接起来.*/task[i].next = task[i-1].next;task[i-1].next = &task[i];}/* start process 0 by task[0] */pid = 0;//初始化 my_current_task 为 task[0]my_current_task = &task[pid];asm volatile("movl %1,%%esp\n\t"     /* 栈的 esp 指向 task[0].thread.sp 的地址 */"pushl %1\n\t"          /* task[0].thread.sp 压栈 */"pushl %0\n\t"          /* task[0].thread.ip 压栈 */"ret\n\t"               /* 将 task[0].thread.ip 保存到 cs:eip 下一条指令执行就从task[0].thread.ip 处开始执行, 即执行 my_process 函数*/"popl %%ebp\n\t"        /* 将 task[0].thread.sp 保存到 ebp */:: "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   /* input c or d mean %ecx/%edx*/);
}

执行完 my_start_kernel 及其他系统启动函数, 最终系统启动.

问题: start_kernel 如何与 mymain.c 中的 my_start_kernel 关联的?

进程运行

目前每个 task 的入口都是 my_process.

void my_process(void) {int i = 0;while(1) {//i 会溢出. 需要在一定大小进行清零i++;//该值越大, 进程切换越不及时.int sched_check_feq = 10000000;//每执行 sched_check_feq 检查一次是否进行内核切换.if(i%sched_check_feq == 0) {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);}if (i == sched_check_feq * 1000) {i = 0;}}
}

中断

在 arch/x86/kernel/time.c 中 setup_default_timer_irq 调用 setup_irq(0, &irq0),
而 irq0.handler = timer_interrupt. timer_interrupt 中调用了 my_timer_handler

因此, 每次时钟中断都会调用 my_timer_handler 函数.

/** 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//该值越大, 进程切换速度越慢. 越小, 进程切换越快.int sched_feq = 1000.//每次时钟中断, time_count 加 1, 当 time_count 整除 1000 时, 重置 my_need_sched 为 1,//my_need_sched = 1 表明下次要进行进程切换. 注意这里 time_count//在制定数量时要重置为 0, 否则 int 类型溢出if(time_count%sched_feq == 0 && my_need_sched != 1) {printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");my_need_sched = 1;}time_count ++ ;if (time_count == 1000000) {time_count = 0;}
#endifreturn;
}

进程调度

以下以 task[0] 切换到 task[1] 为例.

void my_schedule(void)
{tPCB * next;tPCB * prev;//由于 my_current_task 已经在 my_start_kernel 初始化了, 因此, 这里条件不成立.if(my_current_task == NULL|| my_current_task->next == NULL){return;}printk(KERN_NOTICE ">>>my_schedule<<<\n");//next 指向 task[1]next = my_current_task->next;//prev 指向 task[0]prev = my_current_task;//显然条件成立, 因为 task[1].[state] = 0if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */{/* switch to next process */asm volatile(//保持现场"pushl %%ebp\n\t"       /* ebp 压栈, 保存 task[0] 的栈基址 */"movl %%esp,%0\n\t"     /* 保持 esp 到内存变量 task[0]->thread.sp *///切换到 task[1] 的栈"movl %2,%%esp\n\t"     /* 将内存变量 task[1]->thread.sp 赋值给 esp,此时完成了进程栈的切换*///task 下次执行开始地址."movl $1f,%1\n\t"       /* 将 1: 的地址保存到 task[0]->thread.ip *///进行进程切换"pushl %3\n\t"          /* task[1]->thread.ip 压栈."ret\n\t"               /* 将 task[1]->thread.ip 从栈弹出放入 cs:eip,调用 task[1] 的 my_process 函数 *///下次 切换到 task[0] 从此处开始执行"1:\t"                  /*  *///如果切换到 task[0], 先将 ebp 出栈, 恢复 task[0] 的栈"popl %%ebp\n\t": "=m" (prev->thread.sp),"=m" (prev->thread.ip): "m" (next->thread.sp),"m" (next->thread.ip));//已经执行完 task[1] 的 entry 函数. my_current_task 指向 task[1]my_current_task = next;printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);}else{//标记 task[1]->state = 0 可以执行next->state = 0;//my_current_task 指向 task[1]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"       /* 保存 task[0] 栈的 ebp, 压栈, 是否可以保存在内存? */"movl %%esp,%0\n\t"     /* task[0] 的 esp 保存在 task[0]->thread.sp */"movl %2,%%esp\n\t"     /* task[1] 的 esp 保持在 esp */"movl %2,%%ebp\n\t"     /* 将 task[1]->thread.sp 保持在 ebp*/"movl $1f,%1\n\t"       /* 将 1: 地址保存在 task[0]->thread.ip, 下次task[0] 从 1: 处开始执行 */"pushl %3\n\t"          /* task[1]->thread.ip 压栈*/"ret\n\t"               /* cs:eip = task[1]->thread.ip, 从 task[1]->thread.ip处开始执行, 即调用 my_process */: "=m" (prev->thread.sp),"=m" (prev->thread.ip): "m" (next->thread.sp),"m" (next->thread.ip));}return;
}

总结

内核启动后, 调用 start_kernel, 其中调用了 my_start_kernel 函数. 而
my_start_kernel 的内联汇编部分将系统的 cs:eip 指向 task[0].task_entry
(my_process 的地址), 系统栈指向 task[0].thread.sp. cpu 于是开始执行
my_process. 而 my_process 是死循环while(1), 因此一直执行.

此外, 系统每过一段时间会发生一次时钟中断, time_count 加 1. 当
time_count % 1000 == 1 且 my_need_sched != 1 时, 重置 my_need_sched 为 1.
这样, my_process 中的下次执行 while(1) 发现 my_need_sched == 1, 于是根据
my_schedule 调度算法进行进程切换. 将系统当前栈指向 task[1] 的 esp, 将 cs:eip 指向task[1].task_entry(my_process 地址). 于是系统从 my_process 开始执行. (注意我们可以为每个 task 分配不同的处理函数). 即通过时钟中断进行进程切换.

如此往复, 进程从 task[0] -> task[1] -> task[2] -> task[3] -> task[0] 这样进行
无限循环. 当然, 我们可以增加 task 个数, 对 task 进行优先级调整, 权重调整, 需要
改变的仅仅是 my_schedule 部分.

至此, 整个系统就运行起来了.

进程调度算法(my_schedule):

开始先执行 task[0] 第一次调度执行 my_schedule 的 else 部分, 然后切换到 task[1] 执行它的 my_process 函数. 执行完之后, 再次调度, 执行 my_schedule 的 else 部分. 然后切换到 task[2] 执行它的my_process 函数. 之后执行 task[0]. 执行 my_schedule 的 if 部分,切换到 task[1], 执行 my_schedule 的 if 部分; 切换到 task[1], 执行 my_schedule 的 if 部分,如此往复.

刘文学 原创作品转载请注明出处 http://blog.csdn.net/wdxz6547/article/details/50815957 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000