Linux内核设计第二周——操作系统工作原理

Linux内核设计第二周

——操作系统工作原理

作者：宋宸宁（20135315）

一、实验过程

图1 执行效果

从图中可以看出，每执行my_ start_ kernel函数两次或一次，my_ time_ hander函数执行一次。

图2 mymain.c文件关键代码部分

图3 myinterrupt.c文件关键代码部分

二、分析分析进程的启动和进程的切换机制（分析见注释）

1、myinterrupt.c

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

    /*
     * 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% ==  && 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");
        /* schedule */
        next = my_current_task->next;
        prev = my_current_task;
        if(next->state == )/* -1 unrunnable, 0 runnable, >0 stopped */
        {
            /* 进程切换跳转到下一进程 */
            asm volatile(
                "pushl %%ebp\n\t"       /* 保存当前ebp */
                "movl %%esp,%0\n\t"     /* 保存当前esp */
                "movl %2,%%esp\n\t"     /* 重新记录要跳转进程的 esp，%2为 next->thread.sp*/
                "movl $1f,%1\n\t"       /* 保存当前 eip ，%1为prev->thread.ip*/
                "pushl %3\n\t"
                "ret\n\t"               /* 记录要跳转进程的  eip，%3为 next->thread.ip*/
                "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 = ;
            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"       /* 保存当前 ebp */
                "movl %%esp,%0\n\t"     /* 保存当前 esp */
                "movl %2,%%esp\n\t"     /* 重新记录要跳转进程的 esp ，%2为 next->thread.sp*/
                "movl %2,%%ebp\n\t"     /* 重新记录要跳转进程的  ebp，%2为 next->thread.sp */
                "movl $1f,%1\n\t"       /* 保存当前  eip ，%1为prev->thread.ip，%1f就是指标号1:的代码在内存中存储的地址*/
                "pushl %3\n\t"
                "ret\n\t"               /* 重新记录要跳转进程的  eip，%3为 next->thread.ip */
                : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
                : "m" (next->thread.sp),"m" (next->thread.ip)
            );
        }
        return;
    }

2、mymain.c

 /*
     *  linux/mykernel/mymain.c
     *
     *  Kernel internal my_start_kernel
     *
     *  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"

    tPCB task[MAX_TASK_NUM]; //声明一个PCB数组
    tPCB * my_current_task = NULL;  //声明当前task指针
    volatile int my_need_sched = ;  //是否需要调度标志

    void my_process(void);

    void __init my_start_kernel(void)
    {
        int pid = ;
        int i;
        /* 初始化 0号进程*/
        task[pid].pid = pid;
        task[pid].state = ;/* -1 unrunnable, 0 runnable, >0 stopped */
        task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;  /* 实际上是my_process*/
        task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-];
        task[pid].next = &task[pid];  // 定义堆栈的栈顶
        /*创建更多的子进程*/
        for(i=;i<MAX_TASK_NUM;i++)
        {
            memcpy(&task[i],&task[],sizeof(tPCB));
            task[i].pid = i;
            task[i].state = -;
            task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-];
            task[i].next = task[i-].next;
            task[i-].next = &task[i];
        }
        /* 从0号进程开始启动 */
        pid = ;
        my_current_task = &task[pid];
        asm volatile(
            "movl %1,%%esp\n\t"     /* 设置 esp 的值*/
            "pushl %1\n\t"          /* 将 ebp 压栈（此时esp=ebp）,%1相当于task[pid].thread.sp*/
            "pushl %0\n\t"          /* 将 eip 压栈，%0相当于task[pid].thread.ip*/
            "ret\n\t"               /* 相当于 eip 出栈 */
            "popl %%ebp\n\t"        /* 0号进程正是启动 */
            :
            : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   /* input c or d mean %ecx/%edx*/
        );
    }
    void my_process(void)
    {
        int i = ;
        while()
        {
            i++;
            if(i% == )
            {
                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);
            }
        }
    }

3、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;  //保存eip
        unsigned long       sp;  //保存esp
    };

    typedef struct PCB{
        int pid;
        volatile long state;    /* 记录进程状态，-1 未运行, 0 运行中, >0 阻塞停止 */
        char stack[KERNEL_STACK_SIZE];  /* 定义堆栈结构*/
        struct Thread thread;
        unsigned long   task_entry;   /* 定义程序入口，通常是main函数*/
        struct PCB *next;
    }tPCB;

    void my_schedule(void);//调度器函数

三、总结

阐明对“操作系统是如何工作的”的理解。

①操作系统是管理电脑硬件与软件资源的程序，同时也是计算机系统的内核与基石。 
②操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源;控制程序运行;改善人机界面;为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。 
③操作系统是一个庞大的管理控制程序，大致包括5个方面的管理功能:进程与处理机管理、作业管理、存储管理、设备管理、文件管理。
④操作系统通过通过函数调用堆栈和中断机制等，实现其管理功能。

宋宸宁+ 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000