• 2017-2018-1 20179202《Linux内核原理与分析》第三周作业


    一、mykernel 实验 :

    1.深度理解函数调用堆栈:

    上周已经一步步地分析过含有变量的函数调用时堆栈的变化,现在对堆栈框架进行一些补充,以以下程序为例:

     int main()  
    {
        ...
        g(x,y); 
        ...
    }
    int g(int x,int y)
    {
        h(c);.
    }
    int h(int x)
    {
        ...
    }
    

    大致栈空间以及自己领会的函数调用堆栈变化框架:

    2.时间片轮转多道程序代码分析:

    计算机工作的三个法宝是存储程序计算机、函数调用堆栈、中断机制。mykernel 启动后,会调用 my_start_kernel 函数,完成进程的初始化,时钟中断周期性地调用 my_timer_handler函数,完成进程的调度。

    扩展 my_start_kernel 和 my_timer_handler 函数,即修改 mymain.c 和 myinterrupt.c,新增 mypcb.h,模拟时间片轮转的多道程序,现在将内核核心代码加以分析:

    mypcb.h

    struct Thread {
        unsigned long       ip;
        unsigned long       sp;
    };
    
    typedef struct PCB{
        int pid;                                //进程的id号
        volatile long state;                    //进程的状态
        char stack[KERNEL_STACK_SIZE];          //进程的栈
        struct Thread thread;                   //Thread 结构体
        unsigned long   task_entry;             //进程的起始入口地址
        struct PCB *next;                       //指向下一个进程的指针
    }tPCB;
    
    void my_schedule(void);                     //此函数执行进程调度
    

    定义了PCB结构体,包括进程号、状态、堆栈、Thread结构体、入口地址、next指针。

    mymain.c

    (1)初始化所有进程,使成为循环链表:

    #include "mypcb.h"
    
    tPCB task[MAX_TASK_NUM];                        //定义4个进程
    tPCB * my_current_task = NULL;
    volatile int my_need_sched = 0;
    
    void my_process(void);                           //每10000000 来进行进程调度,调用my_schedule
    
    void __init my_start_kernel(void)
    { 
        int pid = 0;                             
        int i;
        task[pid].pid = pid;                       //0号进程pid设为0
        task[pid].state = 0;                       //0号进程state设为可运行
        task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;//0号进程的ip和入口地址设为my_process();
        task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];//0号进程的栈顶为stack数组的最后一个元素
        task[pid].next = &task[pid];                                              //next指针指向自己
        for(i=1;i<MAX_TASK_NUM;i++)                          //1,2,3号进程复制0号进程
        {
            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];                       //当前运行的进程设为0号进程
        );
    }   
    

    (2)0号线程的启动:

     asm volatile(
            "movl %1,%%esp
    	"     //esp指向stack数组的末尾
            "pushl %1
    	"          //将task[0].thread.sp压栈
            "pushl %0
    	"          //将task[0].thread.ip压栈
            "ret
    	"               //eip指向0进程起始地址,启动0号进程
            "popl %%ebp
    	"        //释放栈空间
            : 
            : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)   
    

    myinterrupt.c

    my_timer_handler 函数每隔1000产生一个中断并把 my_need_sched 设置为1,此时 mymain.c 中 my_process 函数调用my_schedule 调度程序进行进程切换。

    (1)时钟中断:

    void my_timer_handler(void)
    {
    #if 1
        if(time_count%1000 == 0 && my_need_sched != 1)
        {
            printk(KERN_NOTICE ">>>my_timer_handler here<<<
    ");
            my_need_sched = 1;
        } 
        time_count ++ ;  
    #endif
        return;      
    }
    

    (2)进程调度

      if(next->state == 0)                  //下一个进程可运行,执行进程切换
        {
            /* switch to next process */   
            asm volatile(    
                "pushl %%ebp
    	"           //保存当前进程的ebp
                "movl %%esp,%0
    	"         //将当前进程的esp储存到当前进程的thread.sp
                "movl %2,%%esp
    	"         //esp指向下一个进程
                "movl $1f,%1
    	"           //将1f存储到thread.sp.$1f是“1:	”处,再次调度到该进程时就会从1:开始执行
                "pushl %3
    	"              //将下一个进程的thread.ip压栈
                "ret
    	"                   //eip指向下一个进程的起始地址
                "1:	"                      
                "popl %%ebp
    	"            //待下一个进程执行完后释放栈空间,恢复现场
                : "=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<<<
    ",prev->pid,next->pid);   
    

    当下一个进程一次也没运行过,执行else后的语句:

    else
        {
            next->state = 0;
            my_current_task = next;
            printk(KERN_NOTICE ">>>switch %d to %d<<<
    ",prev->pid,next->pid);
            /* switch to new process */
            asm volatile(    
                "pushl %%ebp
    	"         /* save ebp */
                "movl %%esp,%0
    	"     /* save esp */
                "movl %2,%%esp
    	"     /* restore  esp */
                "movl %2,%%ebp
    	"     /* restore  ebp */
                "movl $1f,%1
    	"       /* save eip */    
                "pushl %3
    	" 
                "ret
    	"                 /* restore  eip */
                : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
                : "m" (next->thread.sp),"m" (next->thread.ip)
            );          
        }
    

    思考:

    (1)相比if,else多了 "movl %2,%%ebp ",少了"popl %%ebp ",即将esp和ebp指向同一位置,并不恢复原进程,所以此部分是由于进程未运行过,所以要开始执行一个新进程;

    (2)此部分的"movl $1f,%1 "是将进程原来的ip(my_process)替换为$1f,使得它被切换回来(运行状态)进入if,可从标号1:处继续执行[参考Linux内核分析];

    (3)为什么定义Thread时设置sp和ip保存esp和sip,而不设置bp来保存ebp呢?

      pushl $ebp压栈保存现场,popl $ebp出栈恢复现场,不需要单独设置变量来保存ebp就可完成,而eip和esp在进程切换中需要不停地变动,必须设置变量来保存。

    总结:操作系统内核从一个起始位置开始执行,完成初始化操作后,开始执行第一个进程。计算机为每个进程分配一个时间片,如果在时间片结束时进程仍在运行,该进程被阻塞,保存现场后切换到另一个进程,执行完后再返回原进程执行,从而完成进程调度。

    二、课本内容总结:

      进程是操作系统的核心。在Linux系统中,进程和线程不做特别区分,线程是一种特殊的进程。进程存放在每一项类型为 task_struct(进程描述符,包括进程的地址空间、挂起的信号、状态等)的双向循环链表中,在内核栈的尾部创建 thread_info 结构,通过计算偏移间接查找进程描述符。父进程通过调用fork()(fork()使用写时拷贝页实现,即不复制整个进程的地址空间,让父进程和子进程共享同一个拷贝)复制本进程来创建新进程,exec()读取可执行文件并将其载入地址空间开始执行,最终,程序通过exit()系统调用退出执行(如果父进程在子进程前退出,必须为其找到合适的养父进程)。

      系统调用在用户空间进程和硬件设备之间添加了一个中间层。程序员只需和API打交道,内核只和系统调用打交道。访问系统调用,通常用C库中定义的函数调用来进行。每个系统调用被赋予了一个独一无二且不能更改的系统调用号,执行系统调用后陷入内核(内核代表进程执行并处于进程上下文),传递系统调用号和参数,执行系统调用函数,并把返回值带回用户空间。“提供机制而不是策略”,系统调用抽象出用于完成某种目的的函数,至于函数如何使用不需要关心。

    注:在学习进程上下文时搜索到了中断上下文,对二者进行比较:用户空间与内核空间,进程上下文与中断上下文

    三、未解决问题:

    (1)0号进程的启动中"pushl %1 " 是将0号进程的 thread.sp 压栈,这里为什么要将 sp 压栈?孟老师说因为是空栈所以 esp 和 ebp 相同。那 thread.sp 是指针吗? "movl %1,%%esp " 将esp指向 thread.sp,即 esp 和 thread.sp 相同,所以 ebp 和 thread.sp 相同,压 thread.sp 相当于压 ebp,可以这样理解吗?

    (2)PCB结构体定义了stack数组,这个数组是本进程的栈吗?如果是,调度程序中保存当前进程的ebp和eip是压入当前进程的栈还是下一个进程的栈,亦或是各自压入两个栈?

    希望老师和看到的同学能帮我解决一下,谢谢啦!

  • 相关阅读:
    C#MessageBox使用
    ListBox的使用
    中文乱码的几种情况以及解决方法
    使用Application
    Android笔记之标题栏的各种操作
    Android笔记之日期选择器
    Viewpager制作自动左右循环滑动
    JAVA入门到精通-第17讲-排序
    ***JAVA入门到精通-第14讲-final-作业评讲
    JAVA入门到精通-第13讲-抽象类-接口
  • 原文地址:https://www.cnblogs.com/Jspo/p/7672728.html
Copyright © 2020-2023  润新知