2020-2021-1 20209312《Linux内核原理与分析》第三周作业
一． mykernel实验（关于操作系统是如何工作的）
运行并分析一个精简的操作系统内核，理解操作系统是如何工作的
使用实验楼的虚拟机打开shell 然后执行下面的操作
cd LinuxKernel/linux-3.9.4
qemu -kernel arch/x86/boot/bzImage
然后cd mykernel 您可以看到qemu窗口输出的内容的代码mymain.c和myinterrupt.c
使用自己的Linux系统环境搭建过程参见mykernel,其中也可以找到一个简单的时间片轮转多道程序内核代码。
# 注意路径是区分大小的 $ cd ~/LinuxKernel/linux-3.9.4 $ rm -rf mykernel $ patch -p1 < ../mykernel_for_linux3.9.4sc.patch $ make allnoconfig # 编译内核请耐心等待 $ make $ qemu -kernel arch/x86/boot/bzImage
3.实验楼虚拟机开始实验
打开mymain.c文件，下面为mymain.c的函数描述，它是内核启动的起始位置，从这开始并循环。
void __init my_start_kernel(void) { int i = 0; while(1) { i++; if(i%100000 == 0) printk(KERN_NOTICE "my_start_kernel here %d \n",i); } }
myinterrupt.c
void my_timer_handler(void) { printf(KERN_NOTICE "\n>>>>>>>>>>>>>>>>>my_timer_handler here<<<<<<<<<<<<<<<<<<\n\n"); }
关于1和2的结果分析
初始内核的运行结果
关于my_start_kernel()函数，每隔一段时间被my_timer_handler()中断，执行下面的语句
printf(KERN_NOTICE “\n>>>>>>>>>>>>>>>>>my_timer_handler here<<<<<<<<<<<<<<<<<<\n\n”)；
最后再执行my_start_kernel()。
二 修改内核代码，使之成为一个简单的时间片轮转多道程序内核，然后重新编译运行。
简单替换关于三个文件的内容后 重新执行make 再次输入下面代码 重启内核
qemu -kernel arch/x86/boot/bzImage
运行的结果
在下图的结果中，可以看到进程的切换：在0号进程运行过程中，首先是my_timer_handler()被执行，然后是myschedule()被执行，myschedule()这个函数它在运行过程中会打印switch 0（被切换出去的进程号） to 1（切换到的进程号）。然后就跳到新的进程1继续执行。
三 mykernel内核源代码分析
mypcb.h
struct Thread { unsigned long ip; //进程eip unsigned long sp; //进程esp }; typedef struct PCB{ int pid; //进程id volatile long state; //进程状态 char stack[KERNEL_STACK_SIZE]; //进程堆栈 struct Thread thread; // unsigned long task_entry; //进程的起始入口地址 struct PCB *next; //指向下一个进程 }tPCB; void my_schedule(void); //进行进程调度
mymain.c
#include <linux/types.h> #include <linux/string.h> #include <linux/ctype.h> #include <linux/tty.h> #include <linux/vmalloc.h> #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) { int pid = 0 int i; 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]; 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]; } pid = 0; my_current_task = &task[pid]; asm volatile( "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) ); } void my_process(void) { int i = 0; while(1) { i++; if(i%10000000 == 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); } } }
myinterrupt.c
另外还要修改myinterrupt.c文件，增加进程调度函数my_schedule(void)，以进行进程切换。
/* * linux/mykernel/myinterrupt.c * * Kernel internal my_timer_handler * * Copyright (C) 2013 Mengning * */ #include <linux/types.h> #include <linux/string.h> #include <linux/ctype.h> #include <linux/tty.h> #include <linux/vmalloc.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 = 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;//将下一个将要运行的进程设置为my_current_task->next指向的下一个进程。 prev = my_current_task;//将当前进程设置为prev进程。 if(next->state == 0)/*如果下一个将要运行的进程已经处于运行状态 -1 unrunnable, 0 runnable, >0 stopped */ { /* switch to next process */ asm volatile( "pushl %%ebp\n\t" /* 保存当前进程的ebp到自己的栈中。 save ebp */ "movl %%esp,%0\n\t" /* 保存当前进程的esp到自己的栈中。 save esp */ "movl %2,%%esp\n\t" /* 从next->thread.sp中弹出下一个进程的esp。与第二句相对应。 restore esp */ "movl $1f,%1\n\t" /* 将下一个进程的eip设置为1f。$1f就是指标号1:的代码在内存中存储的地址 save eip */ "pushl %3\n\t" /* 将next->thread.ip压入当前进程的栈中。*/ "ret\n\t" /* 从当前进程的栈中弹出刚刚压入的next->thread.ip。完成进程切换。 restore eip */ "1:\t" /* 即$1f指向的位置。next process start here */ "popl %%ebp\n\t" /* 切换到的进程把ebp从栈中弹出至ebp寄存器。与第一句相对应。*/ : "=m" (prev->thread.sp),"=m" (prev->thread.ip) : "m" (next->thread.sp),"m" (next->thread.ip) ); my_current_task = next; //当前进程切换为next printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid); //打印切换信息 } else//如果下一个将要运行的进程还从未运行过。 { next->state = 0;//将其设置为运行状态。 my_current_task = next;////当前进程切换为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" /* 将要被切换出去的进程的ip设置为$1f。这样等一下它被切换回来时（一定是运行状态）肯定会进入if判断分支，可以从if中的标号1处继续执行。 save eip */ "pushl %3\n\t" /* 将next->thread.ip（因为它还没有被运行过，所以next->thread.ip现在仍处于初始状态，即指向my_process()，压入将要被切换出去的进程的堆栈。*/ "ret\n\t" /* 将刚刚压入的next->thread.ip出栈至eip，完成进程切换。 restore eip */ : "=m" (prev->thread.sp),"=m" (prev->thread.ip) : "m" (next->thread.sp),"m" (next->thread.ip) ); } return; }
内核的运行过程，启动内核，启动0号进程进行初始化，下面的代码是0号进程的启动部分。
asm volatile( "movl %1,%%esp\n\t" /*将进程原堆栈栈顶的地址（这里是初始化的值）存入ESP寄存器 */ "pushl %1\n\t" /* 将当前EBP寄存器值入栈 */ "pushl %0\n\t" /* 将当前进程的EIP（这里是初始化的值）入栈*/ "ret\n\t" /* ret命令正好可以让入栈的进程EIP保存到EIP寄存器中*/ "popl %%ebp\n\t" /*这里永远不会被执行，知识与前面push指令结对出现，是一种编码习惯*/ : : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) );
在进程0的时间片用完时，将利用进程调度函数，运行进程1，其调度过程的代码如下：
if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */ { asm volatile( "pushl %%ebp\n\t" "movl %%esp,%0\n\t" "movl %2,%%esp\n\t" "movl $1f,%1\n\t" "pushl %3\n\t" "ret\n\t" "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 { 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" "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) ); }
四 操作系统的运行分析
操作系统在内核启动时，有一个起始位置，从这个起始位置开始执行启动。执行一些初始化操作后，将CPU分配给第一个进程，开始执行第一个进程，然后通过一定的调度算法，比如时间片轮转，在一个时间片后，发生中断，第一个进程被阻塞，在完成保存现场后将CPU分配给下一个进程，执行下一个进程。这样，操作系统就完成了基本的进程调度的功能。
现代操作系统一般都是采用基于时间片的优先级调度算法，把CPU的时间划分为很细粒度的时间片，一个任务每次只能时间这么多的时间，时间到了就必须交出使用权，即换其他的任务使用。
自己看了一会关于操作系统的中断机制 看的迷迷糊糊 还需要继续学习 下面摘录一些关于中断的运行机制
中断信号由外部设备发起，准确来说是由外部设备的控制器发起，因为外部设备本身并不能发起信号。必须网卡设备，的那个网络数据包到达网卡，网卡的控制器就向IO APIC发送中断信号，IO APIC把信号发送给本地APIC，本地APIC把信号传送给CPU，如果根据当时情况，要处理这个中断，就保存当时的运行上下文，切换到中断上下文中，根据IDT查找对应的处理函数进行处理。处理完成后，需要恢复中断之前的状态。
posted on 2020-10-24 19:27 20209312-张伟国 阅读(142) 评论(0) 编辑 收藏 举报
