美文网首页
2操作系统是如何工作的?

2操作系统是如何工作的?

作者: 夏天的篮球 | 来源:发表于2017-03-05 17:24 被阅读0次

    安大大 + 原创作品转载请注明出处 + 《Linux操作系统分析》MOOC课程


    天下大事必作于细,天下难事必作于易

    早期的计算机在没有中断的时候,只能执行完一个程序之后,再执行另外一个程序。有了中断之后,就有了多道程序设计。当一个中断信号发生的时候,CPU把当前的eip,esp,ebp都压到一个叫内核堆栈的另外一个堆栈里。然后把eip指向中断处理程序的入口。即保存现场,执行中断处理程序。由CPU和内核代码共同实现了保存现场和恢复现场。

    实验

    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
    
    运行起来的情形:

    mymain.c文件内容:

    my_start_kernel之前都是硬件初始化的东西,从my_start_kernel函数开始,这就是操作系统的入口,开始启动操作系统。每循环十万次,打印一次"my_start_kernel here",值改的越大,打印的速度就越慢。改完之后make一下。


    myinterrupt.c文件的内容:

    每次时钟中断它都调用一次printk。怎样获取时钟中断,进入始终中断处理程序入口,linux内核的代码已经处理好了。只需要在中断发生的时候,做一些实际的中断处理。


    C代码中嵌入汇编代码

    语法格式 asm("汇编语句":"输出部分":"输入部分":"破坏描述部分");

    例子程序,实现val1+val2=val3
    #include <stdio.h>
    int main()
    {
        /* val1+val2=val3 */
        unsigned int val1 = 1;
        unsigned int val2 = 2;
        unsigned int val3 = 0;
        printf("val1:%d,val2:%d,val3:%d\n",val1,val2,val3);
        asm volatile(
        "movl $0,%%eax\n\t" /* clear %eax to 0*/
        "addl %1,%%eax\n\t" /* %eax += val1 */
        "addl %2,%%eax\n\t" /* %eax += val2 */
        "movl %%eax,%0\n\t" /* val2 = %eax*/
        //从输出部分到输入部分的变量,从零开始计,分别是%0,%1,%2,数字表示第几个参数。
        : "=m" (val3) /* output =m mean only write output memory variable*/
        : "c" (val1),"d" (val2) /* input c or d mean %ecx/%edx*/
        );
        printf("val1:%d+val2:%d=val3:%d\n",val1,val2,val3);
        return 0;
    }
    

    在mykernel基础上构造一个简单的OS内核( 代码分析在注释当中 )

    mypcb.h 进程控制块
    #define MAX_TASK_NUM 4 // max num of task in system
    #define KERNEL_STACK_SIZE 1024*8
    
    struct Thread {
        unsigned long       ip;//存储eip 
        unsigned long       sp;//存储esp 
    };
    typedef struct PCB{//定义进程管理相关的数据结构
        int pid;//进程的id 
        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 内核初始化和0号进程启动
    #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];//PCB类型数组task
    tPCB * my_current_task = NULL;//当前task的指针
    volatile int my_need_sched = 0;//是否需要调度 
    
    void my_process(void);//函数声明
    
    void __init my_start_kernel(void)//初始化 
    {
        int pid = 0;
        /* Initialize process 0 初始化0号进程的数据结构*/
        task[pid].pid = pid;
        task[pid].state = 0;//状态是正在运行 /* -1 unrunnable, 0 runnable, >0 stopped */
        // set task 0 execute entry address to my_process
        task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;//起点,入口,my_process实际上是my_start_kernel
        task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
        task[pid].next = &task[pid];//刚启动,指向自己,系统里只有0号进程,没有其他进程 
        /*fork more process 创建更多的进程*/ 
        for(i=1;i<MAX_TASK_NUM;i++)
        {
            memcpy(&task[i],&task[0],sizeof(tPCB));//把0号进程的状态copy过来
            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;//新fork的进程加到进程列表的尾部 
            task[i-1].next = &task[i];
        }
        /* start process 0 by task[0] 启动0号进程,使0号进程开始执行*/
        pid = 0;
        my_current_task = &task[pid];//当前的进程就是0号进程
        asm volatile(
            "movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp 把第一号参数task[pid].thread.sp放入esp */
            "pushl %1\n\t" /* push ebp 当前栈是空的,esp=ebp,所以直接push了1号参数sp*/
            "pushl %0\n\t" /* push task[pid].thread.ip push当前的ip*/
            "ret\n\t" /* pop task[pid].thread.ip to eip ,pop的eip,my_process的头部*/
            "popl %%ebp\n\t"// ret之后0号进程正式启动了,这几句汇编就按照0号进程设定的堆栈和0号进程的入口构建起来了CPU的运行环境
            :
            : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)    /* input c or d mean %ecx/%edx*/
            //到这里my_start_kernel的工作就做完了,内核的初始化工作完成,并且启动了0号进程
    );
    }
    void my_process(void)
    {
        int i = 0;
        while(1)
        {
            i++;
            if(i%10000000 == 0)//循环1000万次判断一下是否需要调度 
            {
                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);
            }
        }
    }//end of my_process
    
    myinterrupt.c
    #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
        // make sure need schedule after system circle 100 times.
        if(time_count%100 == 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 there no task running or only a task ,it shouldn't need schedule
        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;//当前进程是prev
        if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
        {//save current scene
             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  $1f是指接下来的标号1:的位置*/
             "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 从来没有执行过,所以esp和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; 
    }//end of my_schedule
    

    把mypcb.h,mymain.c,myinterrupt.c放到mykernel目录下,重新make



    运行成功:


    难点分析:
    理解和运行mykernel,它是提供初始化好的CPU从my_start_kernel开始执行,并提供了时钟中断机制周期性执行my_time_handler中断处理程序,执行完后中断返回总是可以回到my_start_kernel中断的位置继续执行。当然中断保存现场恢复现场的细节都处理好了,mykernel就是一个逻辑上的硬件平台,具体怎么做到的一般不必深究。
    能运行mykernel后就可以写一个自己的时间片轮转调度内核了,自己写还是很难的,只需到mykernel的github版本库找到代码复制过来重新编译Linux3.9.4的源代码,能按视频的效果跑起来,这都不难。
    难点是理解基于mykernel实现的时间片轮转调度代码。
    往往系统都有很多进程比较复杂,我们假定当前系统只有两个进程0和1,第一次调度是从0切换到1,也就是prev=0,next=1,第二次调度正好相反。
    这时再看myinterrupt.c中的汇编代码,保存prev的进程(0)上下文,下次调度是next进程就是0了,反之进程1是next那它肯定之前作为prev被调度出去过。理解进程上下文的保存和恢复极为关键。
    $1f就是指标号1:的代码在内存中存储的地址
    再来看特殊一点代码切换到一个新的进程,也就是next没有被保存过进程上下文,它从没有被执行过,这时稍特殊一点即else部分的汇编代码。

    相关文章

      网友评论

          本文标题:2操作系统是如何工作的?

          本文链接:https://www.haomeiwen.com/subject/hjjegttx.html