20135201李辰希《Linux内核》第二周 操作系统是如何工作的

 

《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

一．函数调用堆栈：

1.计算机是如何工作的：

三个法宝：存储程序计算机、函数调用堆栈（堆栈机制是高级语言的起点）、中断机制。

• 存储程序计算机工作模型，计算机系统最最基础性的逻辑结构。
• 函数调用堆栈，高级语言得以运行的基础，只有机器语言和汇编语言的时候堆栈机制对于计算机来说并不那么重要，但有了高级语言及函数，堆栈成为了计算机的基础功能。（函数参数传递机制和局部变量存储）
• 中断，多道程序操作系统的基点，没有中断机制程序只能从头一直运行结束才有可能开始运行其他程序。

2.堆栈作用：

• 函数调用框架
• 传递参数
• 保存返回地址
• 提供局部变量空间

堆栈相关的寄存器

• esp，堆栈指针，指向栈顶
• ebp，基址指针，指向栈底，在C语言中用作记录当前函数调用基址。

其他关键寄存器

cs（代码段寄存器） : eip：总是指向下一条的指令地址

• 顺序执行：总是指向地址连续的下一条指令
• 跳转/分支：执行这样的指令的时候， cs : eip的值会根据程序需要被修改

参数传递与局部变量

• 建立框架（相当于 call 指令）

  push %ebp
  movl %esp,%ebp

• 拆除框架（相当于 ret 指令）

  movl %ebp,%esp
  pop  %ebp

函数返回时一定会拆除框架，建立和拆除是一一对应的。

• 传递参数

在建立子函数的框架之前，局部变量的值保存在调用者堆栈框架中，所以在子函数框架建立之前可以采用变址寻址的方式将变量值入栈。

 

 

二．借助Linux内核部分源代码模拟存储程序计算机工作模型及时钟中断

Kernel实验背后涉及的思想：由CPU和内核代码共同实现了保存现场和恢复现场。

 

三.实验：mykernel基础上构造一个简单的操作系统内核

 1.嵌汇编语法

    __asm__(               
    汇编语句模版：
    输出部分：
    输入部分：
 破坏描述部分）；

2.实验步骤
首先运行此内核，可以看到提供可一个代码在内核中运行的上下文环境。

然后cd mykernel 找到mymain.c和myinterrupt.c两个源代码

  每循环十万次，打印一个my_start_kernel。

 打开 Myinterrupt.c：

 

3.个简单的时间片轮转多道程序内核代码

 

#define MAX_TASK_NUM        4

#define KERNEL_STACK_SIZE   1024*8

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

void my_schedule(void);

 

 

#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;

    /* Initialize process 0*/

    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];

    /*fork more process */

    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];

    }

    /* start process 0 by task[0] */

    pid = 0;

    my_current_task = &task[pid];

      asm volatile(

       "movl %1,%%esp\n\t"     /* set task[pid].thread.sp to esp */

       "pushl %1\n\t"            /* push ebp */

       "pushl %0\n\t"            /* push task[pid].thread.ip */

       "ret\n\t"               /* pop task[pid].thread.ip to eip */

       "popl %%ebp\n\t"

       :

       : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) /* input c or d mean %ecx/%edx*/

      );

}  

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);

        }    

    }

}

 

 

#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;

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;

    prev = my_current_task;

    if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */

    {

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

             "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)

       );

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

}

 

总结

如何理解操作系统是怎样工作的：

1.操作系统是建立在硬件基础上的，基于CPU对整个机器的资源进行管理和调度。

2.操作系统是两把剑：中断上下文和进程上下文的切换。

3.而Linux是一个多进程的操作系统。

转载于:https://www.cnblogs.com/20135201lcx2/p/5247522.html